Start branch for beta2 release

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1053042 13f79535-47bb-0310-9956-ffa450edef68

9 files changed, 2207 insertions, 0 deletions

diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/Collection.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/Collection.java
new file mode 100644
index 0000000000..81ec1ddad3
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/Collection.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.atom.collection;
+
+import org.apache.abdera.model.Entry;
+import org.apache.abdera.model.Feed;
+import org.oasisopen.sca.annotation.Remotable;
+
+/**
+ * Provides access to a collection of resources using Atom.
+ * 
+ * @version $Rev$ $Date$
+ */
+@Remotable
+public interface Collection {
+
+    /**
+     * Get an Atom feed for a collection of resources.
+     * 
+     * @return the Atom feed
+     */
+    Feed getFeed();
+
+    /**
+     * Get an Atom feed for a collection of resources resulting
+     * from a query.
+     * 
+     * @param queryString a query string
+     * @return the Atom feed
+     */
+    Feed query(String queryString);
+
+    /**
+     * Creates a new entry.
+     * 
+     * @param entry
+     * @return
+     */
+    Entry post(Entry entry);
+
+    /**
+     * Retrieves an entry.
+     * 
+     * @param id
+     * @return
+     */
+    Entry get(String id) throws NotFoundException;
+
+    /**
+     * Update an entry.
+     * 
+     * @param id
+     * @param entry
+     * @return
+     */
+    void put(String id, Entry entry) throws NotFoundException;
+
+    /**
+     * Delete an entry.
+     * 
+     * @param id
+     */
+    void delete(String id) throws NotFoundException;
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/MediaCollection.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/MediaCollection.java
new file mode 100644
index 0000000000..d318e5b7e7
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/MediaCollection.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.atom.collection;
+
+import java.io.InputStream;
+
+import org.apache.abdera.model.Entry;
+import org.oasisopen.sca.annotation.Remotable;
+
+/**
+ * Provides access to a collection of resources using Atom.
+ * 
+ * @version $Rev$ $Date$
+ */
+@Remotable
+public interface MediaCollection extends Collection {
+
+    /**
+     * Creates a new media entry
+     * 
+     * @param title
+     * @param slug
+     * @param contentType
+     * @param media
+     */
+    Entry postMedia(String title, String slug, String contentType, InputStream media);
+
+    /**
+     * Update a media entry.
+     * 
+     * @param id
+     * @param contentType
+     * @param media
+     * @return
+     */
+    void putMedia(String id, String contentType, InputStream media) throws NotFoundException;
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/NotFoundException.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/NotFoundException.java
new file mode 100644
index 0000000000..b457840922
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/collection/NotFoundException.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.atom.collection;
+
+/**
+ * Indicates that a resource could not be found.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class NotFoundException extends Exception {
+    private static final long serialVersionUID = -5046027674128627383L;
+
+    public NotFoundException() {
+    }
+
+    public NotFoundException(String message) {
+        super(message);
+    }
+
+    public NotFoundException(Throwable cause) {
+        super(cause);
+    }
+
+    public NotFoundException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingInvoker.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingInvoker.java
new file mode 100644
index 0000000000..c1de646f54
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingInvoker.java
@@ -0,0 +1,608 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import static org.apache.tuscany.sca.binding.atom.provider.AtomBindingUtil.entry;
+import static org.apache.tuscany.sca.binding.atom.provider.AtomBindingUtil.feedEntry;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.abdera.Abdera;
+import org.apache.abdera.factory.Factory;
+import org.apache.abdera.model.Document;
+import org.apache.abdera.model.Feed;
+import org.apache.abdera.parser.Parser;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.entity.StringEntity;
+import org.apache.tuscany.sca.binding.atom.collection.NotFoundException;
+import org.apache.tuscany.sca.data.collection.Entry;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.oasisopen.sca.ServiceRuntimeException;
+
+/**
+ * Invoker for the Atom binding.
+ * 
+ * @version $Rev$ $Date$
+ */
+class AtomBindingInvoker implements Invoker {
+
+    private static final Factory abderaFactory = Abdera.getNewFactory();
+    private static final Parser abderaParser = Abdera.getNewParser();
+
+    Operation operation;
+    String uri;
+    HttpClient httpClient;
+    String authorizationHeader;
+    AtomReferenceBindingProvider provider;
+
+    AtomBindingInvoker(Operation operation,
+                       String uri,
+                       org.apache.http.client.HttpClient httpClient,
+                       String authorizationHeader,
+                       AtomReferenceBindingProvider bindingProvider) {
+        this.operation = operation;
+        this.uri = uri;
+        this.httpClient = httpClient;
+        this.authorizationHeader = authorizationHeader;
+        this.provider = bindingProvider;
+    }
+
+    public Message invoke(Message msg) {
+        // Shouldn't get here, as the only supported methods are
+        // defined in the ResourceCollection interface, and implemented
+        // by specific invoker subclasses
+        throw new UnsupportedOperationException(operation.getName());
+    }
+
+    /**
+     * Get operation invoker
+     */
+    public static class GetInvoker extends AtomBindingInvoker {
+
+        public GetInvoker(Operation operation,
+                          String uri,
+                          org.apache.http.client.HttpClient httpClient,
+                          String authorizationHeader,
+                          AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Get an entry
+            String id = (String)((Object[])msg.getBody())[0];
+
+            // Send an HTTP GET
+            HttpGet getMethod = new HttpGet(uri + "/" + id);
+            if (authorizationHeader != null) {
+                getMethod.setHeader("Authorization", authorizationHeader);
+            }
+            boolean parsing = false;
+            HttpResponse response = null;
+            try {
+                response = httpClient.execute(getMethod);
+                int status = response.getStatusLine().getStatusCode();
+
+                // Read the Atom entry
+                if (status == 200) {
+                    InputStream content = response.getEntity().getContent();
+                    Document<org.apache.abdera.model.Entry> doc = abderaParser.parse(content);
+                    content.close();
+                    parsing = true;
+                    org.apache.abdera.model.Entry feedEntry = doc.getRoot();
+
+                    if (provider.supportsFeedEntries()) {
+
+                        // Return the Atom entry
+                        msg.setBody(feedEntry);
+
+                    } else {
+
+                        // Convert the feed entry to a data entry and return the data item
+                        Entry<Object, Object> entry =
+                            entry(feedEntry,
+                                  provider.getItemClassType(),
+                                  provider.getItemXMLType(),
+                                  provider.getMediator());
+                        msg.setBody(entry.getData());
+                    }
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries())
+                        msg.setFaultBody(new NotFoundException());
+                    else
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+
+                // Release the connection unless the Abdera parser is
+                // parsing the response, in this case it will release it
+                release(getMethod, response);
+
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Post operation invoker
+     */
+    public static class PostInvoker extends AtomBindingInvoker {
+
+        public PostInvoker(Operation operation,
+                           String uri,
+                           HttpClient httpClient,
+                           String authorizationHeader,
+                           AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Post an entry
+            Object[] args = (Object[])msg.getBody();
+            org.apache.abdera.model.Entry feedEntry;
+            if (provider.supportsFeedEntries()) {
+
+                // Expect an Atom entry
+                feedEntry = (org.apache.abdera.model.Entry)args[0];
+            } else {
+
+                // Expect a key and data item
+                Entry<Object, Object> entry = new Entry<Object, Object>(args[0], args[1]);
+                feedEntry =
+                    feedEntry(entry,
+                              provider.getItemClassType(),
+                              provider.getItemXMLType(),
+                              provider.getMediator(),
+                              abderaFactory);
+            }
+
+            // Send an HTTP POST
+            HttpPost postMethod = new HttpPost(uri);
+            if (authorizationHeader != null) {
+                postMethod.setHeader("Authorization", authorizationHeader);
+            }
+            boolean parsing = false;
+            HttpResponse response = null;
+            try {
+
+                // Write the Atom entry
+                StringWriter writer = new StringWriter();
+                feedEntry.writeTo(writer);
+                // postMethod.setHeader("Content-type", "application/atom+xml; charset=utf-8");
+                postMethod.setHeader("Content-type", "application/atom+xml;type=entry");
+                postMethod.setEntity(new StringEntity(writer.toString()));
+
+                response = httpClient.execute(postMethod);
+                int status = response.getStatusLine().getStatusCode();
+
+                // Read the Atom entry
+                if (status == 200 || status == 201) {
+                    InputStream content = postMethod.getEntity().getContent();
+                    Document<org.apache.abdera.model.Entry> doc = abderaParser.parse(content);
+                    content.close();
+                    parsing = true;
+                    org.apache.abdera.model.Entry createdEntry = doc.getRoot();
+
+                    // Returns the created Atom entry ID
+                    if (provider.supportsFeedEntries()) {
+
+                        // Returns the created entry
+                        msg.setBody(createdEntry);
+
+                    } else {
+
+                        // Returns the id of the created entry 
+                        msg.setBody(createdEntry.getId().toString());
+                    }
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries())
+                        msg.setFaultBody(new NotFoundException());
+                    else
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+
+                // Release the connection unless the Abdera parser is
+                // parsing the response, in this case it will release it
+                release(postMethod, response);
+
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Put operation invoker
+     */
+    public static class PutInvoker extends AtomBindingInvoker {
+
+        public PutInvoker(Operation operation,
+                          String uri,
+                          HttpClient httpClient,
+                          String authorizationHeader,
+                          AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Put an entry
+            Object[] args = (Object[])msg.getBody();
+            String id;
+            org.apache.abdera.model.Entry feedEntry;
+            if (provider.supportsFeedEntries()) {
+
+                // Expect a key and Atom entry
+                id = (String)args[0];
+                feedEntry = (org.apache.abdera.model.Entry)args[1];
+            } else {
+
+                // Expect a key and data item
+                id = (String)args[0];
+                Entry<Object, Object> entry = new Entry<Object, Object>(id, args[1]);
+                feedEntry =
+                    feedEntry(entry,
+                              provider.getItemClassType(),
+                              provider.getItemXMLType(),
+                              provider.getMediator(),
+                              abderaFactory);
+            }
+
+            // Send an HTTP PUT
+            HttpPut putMethod = new HttpPut(uri + "/" + id);
+            if (authorizationHeader != null) {
+                putMethod.setHeader("Authorization", authorizationHeader);
+            }
+
+            HttpResponse response = null;
+            try {
+
+                // Write the Atom entry
+                StringWriter writer = new StringWriter();
+                feedEntry.writeTo(writer);
+                putMethod.setHeader("Content-type", "application/atom+xml; charset=utf-8");
+                putMethod.setEntity(new StringEntity(writer.toString()));
+
+                response = httpClient.execute(putMethod);
+                int status = response.getStatusLine().getStatusCode();
+                if (status == 200 || status == 201 || status == 412) {
+
+                    msg.setBody(null);
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries())
+                        msg.setFaultBody(new NotFoundException());
+                    else
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                release(putMethod, response);
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Delete operation invoker
+     */
+    public static class DeleteInvoker extends AtomBindingInvoker {
+
+        public DeleteInvoker(Operation operation,
+                             String uri,
+                             HttpClient httpClient,
+                             String authorizationHeader,
+                             AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Delete an entry
+            String id = (String)((Object[])msg.getBody())[0];
+
+            // Send an HTTP DELETE
+            HttpDelete deleteMethod = new HttpDelete(uri + "/" + id);
+            if (authorizationHeader != null) {
+                deleteMethod.setHeader("Authorization", authorizationHeader);
+            }
+            HttpResponse response = null;
+            try {
+                response = httpClient.execute(deleteMethod);
+                int status = response.getStatusLine().getStatusCode();
+                if (status == 200) {
+                    msg.setBody(null);
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries())
+                        msg.setFaultBody(new NotFoundException());
+                    else
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                release(deleteMethod, response);
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * GetAll operation invoker
+     */
+    public static class GetAllInvoker extends AtomBindingInvoker {
+
+        public GetAllInvoker(Operation operation,
+                             String uri,
+                             HttpClient httpClient,
+                             String authorizationHeader,
+                             AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Get a feed
+
+            // Send an HTTP GET
+            HttpGet getMethod = new HttpGet(uri);
+            if (authorizationHeader != null) {
+                getMethod.setHeader("Authorization", authorizationHeader);
+            }
+            boolean parsing = false;
+            HttpResponse response = null;
+            try {
+                response = httpClient.execute(getMethod);
+                int status = response.getStatusLine().getStatusCode();
+                // AtomBindingInvoker.printResponseHeader( getMethod );
+
+                // Read the Atom feed
+                if (status == 200) {
+                    InputStream content = response.getEntity().getContent();
+                    Document<Feed> doc = abderaParser.parse(content);
+                    content.close();
+                    parsing = true;
+
+                    Feed feed = null;
+                    try {
+                        feed = doc.getRoot();
+                    } catch (Exception e) {
+                        throw new IllegalArgumentException("Invalid feed format :" + uri);
+                    }
+
+                    if (provider.supportsFeedEntries()) {
+
+                        // Returns the Atom feed
+                        msg.setBody(feed);
+
+                    } else {
+
+                        // Returns an array of data entries
+                        List<Entry<Object, Object>> entries = new ArrayList<Entry<Object, Object>>();
+                        for (org.apache.abdera.model.Entry feedEntry : feed.getEntries()) {
+                            Entry<Object, Object> entry =
+                                entry(feedEntry,
+                                      provider.getItemClassType(),
+                                      provider.getItemXMLType(),
+                                      provider.getMediator());
+                            entries.add(entry);
+                        }
+                        msg.setBody(entries.toArray(new Entry[entries.size()]));
+                    }
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries()) {
+                        msg.setFaultBody(new NotFoundException());
+                    } else {
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                    }
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+
+                // Release the connection unless the Abdera parser is
+                // parsing the response, in this case it will release it
+                release(getMethod, response);
+
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Query operation invoker
+     */
+    public static class QueryInvoker extends AtomBindingInvoker {
+
+        public QueryInvoker(Operation operation,
+                            String uri,
+                            HttpClient httpClient,
+                            String authorizationHeader,
+                            AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // Get a feed from a query
+            String queryString = (String)((Object[])msg.getBody())[0];
+
+            // Send an HTTP GET
+            HttpGet getMethod = new HttpGet(uri + "?" + queryString);
+            if (authorizationHeader != null) {
+                getMethod.setHeader("Authorization", authorizationHeader);
+            }
+            // getMethod.setQueryString(queryString);
+            boolean parsing = false;
+            HttpResponse response = null;
+            try {
+                response = httpClient.execute(getMethod);
+                int status = response.getStatusLine().getStatusCode();
+
+                // Read the Atom feed
+                if (status == 200) {
+                    InputStream content = response.getEntity().getContent();
+                    Document<Feed> doc = abderaParser.parse(content);
+                    content.close();
+                    parsing = true;
+                    Feed feed = doc.getRoot();
+
+                    if (provider.supportsFeedEntries()) {
+
+                        // Returns the Atom feed
+                        msg.setBody(feed);
+
+                    } else {
+
+                        // Returns an array of data entries
+                        List<Entry<Object, Object>> entries = new ArrayList<Entry<Object, Object>>();
+                        for (org.apache.abdera.model.Entry feedEntry : feed.getEntries()) {
+                            Entry<Object, Object> entry =
+                                entry(feedEntry,
+                                      provider.getItemClassType(),
+                                      provider.getItemXMLType(),
+                                      provider.getMediator());
+                            entries.add(entry);
+                        }
+                        msg.setBody(entries.toArray(new Entry[entries.size()]));
+                    }
+
+                } else if (status == 404) {
+                    if (provider.supportsFeedEntries())
+                        msg.setFaultBody(new NotFoundException());
+                    else
+                        msg.setFaultBody(new org.apache.tuscany.sca.data.collection.NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+
+                // Release the connection unless the Abdera parser is
+                // parsing the response, in this case it will release it
+                release(getMethod, response);
+
+            }
+
+            return msg;
+        }
+    }
+
+    private static void release(HttpRequestBase request, HttpResponse response) {
+
+        if (response != null) {
+            HttpEntity entity = response.getEntity();
+            if (entity != null) {
+                try {
+                    entity.consumeContent();
+                } catch (IOException e) {
+                    if (request != null) {
+                        request.abort();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * PostMedia operation invoker
+     */
+    public static class PostMediaInvoker extends AtomBindingInvoker {
+
+        public PostMediaInvoker(Operation operation,
+                                String uri,
+                                HttpClient httpClient,
+                                String authorizationHeader,
+                                AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // PostInvoker can detect media by content type (non-Feed, non-Entry)
+            return super.invoke(msg);
+        }
+    }
+
+    /**
+     * PutMedia operation invoker
+     */
+    public static class PutMediaInvoker extends AtomBindingInvoker {
+
+        public PutMediaInvoker(Operation operation,
+                               String uri,
+                               HttpClient httpClient,
+                               String authorizationHeader,
+                               AtomReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // PutInvoker can detect media by content type (non-Feed, non-Entry)
+            return super.invoke(msg);
+        }
+    }
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingListenerServlet.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingListenerServlet.java
new file mode 100644
index 0000000000..d5ae26e01b
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingListenerServlet.java
@@ -0,0 +1,903 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import static org.apache.tuscany.sca.binding.atom.provider.AtomBindingUtil.entry;
+import static org.apache.tuscany.sca.binding.atom.provider.AtomBindingUtil.feedEntry;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+import java.net.URLDecoder;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.logging.Logger;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.abdera.Abdera;
+import org.apache.abdera.factory.Factory;
+import org.apache.abdera.i18n.iri.IRI;
+import org.apache.abdera.model.Category;
+import org.apache.abdera.model.Collection;
+import org.apache.abdera.model.Document;
+import org.apache.abdera.model.Feed;
+import org.apache.abdera.model.Link;
+import org.apache.abdera.model.Service;
+import org.apache.abdera.model.Workspace;
+import org.apache.abdera.parser.ParseException;
+import org.apache.abdera.parser.Parser;
+import org.apache.abdera.writer.WriterFactory;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.tuscany.sca.common.http.HTTPCacheContext;
+import org.apache.tuscany.sca.common.http.HTTPUtil;
+import org.apache.tuscany.sca.data.collection.Entry;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl;
+import org.apache.tuscany.sca.invocation.InvocationChain;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.apache.tuscany.sca.invocation.MessageFactory;
+import org.apache.tuscany.sca.runtime.Invocable;
+
+/**
+ * A resource collection binding listener, implemented as a Servlet and
+ * registered in a Servlet host provided by the SCA hosting runtime.
+ *
+ * @version $Rev$ $Date$
+ */
+class AtomBindingListenerServlet extends HttpServlet {
+    private static final Logger logger = Logger.getLogger(AtomBindingListenerServlet.class.getName());
+    private static final long serialVersionUID = 1L;
+
+    private static final Factory abderaFactory = Abdera.getNewFactory();
+    private static final Parser abderaParser = Abdera.getNewParser();
+    private static final String ETAG = "ETag";
+    private static final String LASTMODIFIED = "Last-Modified";    
+    private static final String LOCATION = "Location";    
+    private static final String CONTENTLOCATION = "Content-Location";    
+    private static final SimpleDateFormat dateFormat = new SimpleDateFormat( "EEE, dd MMM yyyy HH:mm:ss Z" ); // RFC 822 date time
+
+    private Invocable wire;
+    private Invoker getFeedInvoker;
+    private Invoker getAllInvoker;
+    private Invoker queryInvoker;
+    private Invoker getInvoker;
+    private Invoker postInvoker;
+    private Invoker postMediaInvoker;
+    private Invoker putInvoker;
+    private Invoker putMediaInvoker;
+    private Invoker deleteInvoker;
+    private MessageFactory messageFactory;
+    private String title;
+    private String description;
+    private Mediator mediator;
+    private DataType<?> itemClassType;
+    private DataType<?> itemXMLType;
+    private boolean supportsFeedEntries;
+
+    /**
+     * Constructs a new binding listener.
+     * 
+     * @param wire
+     * @param messageFactory
+     * @param feedType
+     */
+    AtomBindingListenerServlet(Invocable wire, MessageFactory messageFactory, Mediator mediator, String title, String description) {
+        this.wire = wire;
+        this.messageFactory = messageFactory;
+        this.mediator = mediator;
+        this.title = title;
+        this.description = description;
+
+        // Get the invokers for the supported operations
+        Operation getOperation = null;
+        for (InvocationChain invocationChain : this.wire.getInvocationChains()) {
+            invocationChain.setAllowsPassByReference(true);
+            Operation operation = invocationChain.getTargetOperation();
+            String operationName = operation.getName();
+            if (operationName.equals("getFeed")) {
+                getFeedInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("getAll")) {
+                getAllInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("query")) {
+                queryInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("get")) {
+                getInvoker = invocationChain.getHeadInvoker();
+                getOperation = operation;
+            } else if (operationName.equals("put")) {
+                putInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("putMedia")) {
+                putMediaInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("post")) {
+                postInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("postMedia")) {
+                postMediaInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("delete")) {
+                deleteInvoker = invocationChain.getHeadInvoker();
+            }
+        }
+
+        // Determine the collection item type
+        if (getOperation != null) {
+            itemXMLType = new DataTypeImpl<Class<?>>(String.class.getName(), String.class, String.class);
+            Class<?> itemClass = getOperation.getOutputType().getLogical().get(0).getPhysical();
+            if (itemClass == org.apache.abdera.model.Entry.class) {
+                supportsFeedEntries = true;
+            }
+            //We assume that the item type is the same for both input and 
+            //ouput for all operations on the interface
+            itemClassType = getOperation.getOutputType().getLogical().get(0);
+        }
+    }
+
+    @Override
+    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+
+        // No authentication required for a get request
+
+        // Test for any cache info in the request
+        HTTPCacheContext cacheContext = null;    	
+        try { 
+            cacheContext = HTTPCacheContext.createCacheContextFromRequest( request );
+        } catch ( java.text.ParseException e ) {    
+        }
+        // System.out.println( "AtomBindingListener.doGet cache context=" + cacheContext );
+
+        // Get the request path
+        //int servletPathLength = request.getContextPath().length() + request.getServletPath().length();
+        //String path = URLDecoder.decode(request.getRequestURI().substring(servletPathLength), "UTF-8");
+
+        String path = URLDecoder.decode(HTTPUtil.getRequestPath(request), "UTF-8");
+        
+        logger.fine("get " + request.getRequestURI());
+
+        // Handle an Atom request
+        if (path != null && path.equals("/atomsvc")) {
+            /*
+             <?xml version='1.0' encoding='UTF-8'?>
+             <service xmlns="http://www.w3.org/2007/app" xmlns:atom="http://www.w3.org/2005/Atom">
+                <workspace>
+                   <atom:title type="text">resource</atom:title>
+                   <collection href="http://luck.ibm.com:8084/customer">
+                      <atom:title type="text">entries</atom:title>
+                      <accept>application/atom+xml;type=entry</accept>
+                      <categories />
+                   </collection>
+                </workspace>
+             </service>
+             */
+
+            // Return the Atom service document
+            response.setContentType("application/atomsvc+xml; charset=utf-8");
+
+            String href = request.getRequestURL().toString();
+            href = href.substring(0, href.length() - "/atomsvc".length());
+
+            String workspaceURL = new String( href );
+            int pathIndex = workspaceURL.indexOf( request.getServletPath() );
+            if ( -1 != pathIndex ) {
+                workspaceURL = workspaceURL.substring( 0, pathIndex ) + "/";
+            }
+
+            Service service = abderaFactory.newService();
+            //service.setText("service");
+
+            Workspace workspace = abderaFactory.newWorkspace();
+            if ( title != null ) {
+                workspace.setTitle(title);
+            } else {
+                workspace.setTitle("workspace");
+            }
+            workspace.setBaseUri( new IRI( workspaceURL ));
+
+            Collection collection = workspace.addCollection("collection", href );
+            Feed feed = getFeed( request );
+            if ( feed != null ) {
+                String title = feed.getTitle();
+                if ( title != null ) {
+                    collection.setTitle(title);
+                } else {
+                    collection.setTitle("entries");
+                }
+                collection.addAccepts("application/atom+xml;type=feed");
+                collection.addAccepts("application/json;type=feed");
+                collection.addAccepts("application/atom+xml;type=entry");
+                collection.addAccepts("application/json;type=entry");
+                List<Category> categories = feed.getCategories();
+                if ( categories != null ) {
+                    collection.addCategories(categories, false, null); 
+                } else {
+                    collection.addCategories().setFixed(false);
+                }
+
+            } else {
+                collection.setTitle("entries");
+                // collection.addAccepts("application/atom+xml;type=feed");
+                collection.addAccepts("application/atom+xml; type=entry");
+                collection.addAccepts("application/json;type=entry");
+                collection.addCategories().setFixed(false);            
+            }
+            workspace.addCollection(collection);
+            service.addWorkspace(workspace);
+
+            //FIXME add prettyPrint support
+            try {
+                service.getDocument().writeTo(response.getOutputStream());
+            } catch (IOException ioe) {
+                throw new ServletException(ioe);
+            }
+
+        } else if (path == null || path.length() == 0 || path.equals("/")) {
+
+            // Return a feed containing the entries in the collection
+            Feed feed = getFeed( request );
+            if (feed != null) {
+                String feedETag = null;
+                if (feed.getId() != null)
+                    feedETag = "\"" + feed.getId().toString() + "\"";
+                Date feedUpdated = feed.getUpdated();
+                // Test request for predicates.
+                String predicate = request.getHeader( "If-Match" );
+                if (( predicate != null ) && ( !predicate.equals(feedETag) )) {
+                    // No match, should short circuit
+                    response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
+                    return;
+                }
+                predicate = request.getHeader( "If-None-Match" );
+                if (( predicate != null ) && ( predicate.equals(feedETag) )) {
+                    // Match, should short circuit
+                    response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
+                    return;
+                }
+                if ( feedUpdated != null ) {
+                    predicate = request.getHeader( "If-Unmodified-Since" );                
+                    if ( predicate != null ) {
+                        try {
+                            Date predicateDate = dateFormat.parse( predicate ); 
+                            if ( predicateDate.compareTo( exactSeconds(feedUpdated) ) < 0 ) {
+                                // Match, should short circuit
+                                response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
+                                return;
+                            }             		
+                        } catch ( java.text.ParseException e ) {
+                            // Ignore and move on
+                        }
+                    }
+                    predicate = request.getHeader( "If-Modified-Since" );                
+                    if ( predicate != null ) {
+                        try {
+                            Date predicateDate = dateFormat.parse( predicate ); 
+                            if ( predicateDate.compareTo( exactSeconds(feedUpdated) ) >= 0 ) {
+                                // Match, should short circuit
+                                response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
+                                return;
+                            }             		
+                        } catch ( java.text.ParseException e ) {
+                            // Ignore and move on
+                        }
+                    }
+                }
+                // Provide Etag based on Id and time if given.
+                // Ignore if not given. (Browser may cache if trivial ETag is given.)
+                if ( feedETag != null ) {
+                    response.addHeader(ETAG, feedETag);
+                }
+                if ( feedUpdated != null ) {
+                    response.addHeader(LASTMODIFIED, dateFormat.format( feedUpdated ));
+                }
+
+                // Content negotiation
+                String acceptType = request.getHeader( "Accept" );
+                String preferredType = getContentPreference( acceptType ); 
+                if (( preferredType != null ) && ((preferredType.indexOf( "json") > -1) || (preferredType.indexOf( "JSON") > -1 ))) {
+                    // JSON response body
+                    response.setContentType("application/json;type=feed");
+
+                    try {
+                        Abdera abdera = new Abdera();
+                        WriterFactory wf = abdera.getWriterFactory();
+                        org.apache.abdera.writer.Writer json = wf.getWriter("json");
+                        feed.writeTo(json, response.getWriter());
+                    } catch (Exception e) {
+                        throw new ServletException(e);
+                    }           		
+
+                } else {
+                    // Write the Atom feed
+                    response.setContentType("application/atom+xml;type=feed");
+                    try {
+                        feed.getDocument().writeTo(response.getOutputStream());
+                    } catch (IOException ioe) {
+                        throw new ServletException(ioe);
+                    }
+                }
+            } else {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            }
+
+        } else if (path.startsWith("/")) {
+            // Return a specific entry in the collection
+            org.apache.abdera.model.Entry feedEntry;
+
+            // Invoke the get operation on the service implementation
+            Message requestMessage = messageFactory.createMessage();
+            String id = path.substring(1);
+            requestMessage.setBody(new Object[] {id});
+            Message responseMessage = getInvoker.invoke(requestMessage);
+            if (responseMessage.isFault()) {
+                Object body = responseMessage.getBody();
+                if (body.getClass().getName().endsWith(".NotFoundException")) {
+                    response.sendError(HttpServletResponse.SC_NOT_FOUND);
+                    return;
+                } else {
+                    throw new ServletException((Throwable)responseMessage.getBody());
+                }
+
+            }
+            if (supportsFeedEntries) {
+                // The service implementation returns a feed entry 
+                feedEntry = responseMessage.getBody();
+            } else {
+                // The service implementation only returns a data item, create an entry
+                // from it
+                Entry<Object, Object> entry = new Entry<Object, Object>(id, responseMessage.getBody()); 
+                feedEntry = feedEntry(entry, itemClassType, itemXMLType, mediator, abderaFactory);
+            }
+            // Write the Atom entry
+            if (feedEntry != null) {
+                String entryETag = null;
+                if (feedEntry.getId() != null)
+                    entryETag = feedEntry.getId().toString();
+                Date entryUpdated = feedEntry.getUpdated();
+                if ( entryUpdated != null )
+                    response.addHeader(LASTMODIFIED, dateFormat.format( entryUpdated ));
+                // TODO Check If-Modified-Since If-Unmodified-Since predicates against LASTMODIFIED. 
+                // If true return 304 and null body.
+
+                Link link = feedEntry.getSelfLink();
+                if (link != null) {
+                    response.addHeader(LOCATION, link.getHref().toString());
+                } else {
+                    link = feedEntry.getLink( "Edit" );
+                    if (link != null) {
+                        response.addHeader(LOCATION, link.getHref().toString());
+                    }
+                }
+
+                // Test request for predicates.
+                String predicate = request.getHeader( "If-Match" );
+                if (( predicate != null ) && ( !predicate.equals(entryETag) )) {
+                    // No match, should short circuit
+                    response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
+                    return;
+                }
+                predicate = request.getHeader( "If-None-Match" );
+                if (( predicate != null ) && ( predicate.equals(entryETag) )) {
+                    // Match, should short circuit
+                    response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
+                    return;
+                }
+                if ( entryUpdated != null ) {
+                    predicate = request.getHeader( "If-Unmodified-Since" );                
+                    if ( predicate != null ) {
+                        try {
+                            Date predicateDate = dateFormat.parse( predicate ); 
+                            if ( predicateDate.compareTo( entryUpdated ) < 0 ) {
+                                // Match, should short circuit
+                                response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
+                                return;
+                            }             		
+                        } catch ( java.text.ParseException e ) {
+                            // Ignore and move on
+                        }
+                    }
+                    predicate = request.getHeader( "If-Modified-Since" );                
+                    if ( predicate != null ) {
+                        try {
+                            Date predicateDate = dateFormat.parse( predicate ); 
+                            if ( predicateDate.compareTo( entryUpdated ) > 0 ) {
+                                // Match, should short circuit
+                                response.sendError(HttpServletResponse.SC_NOT_MODIFIED);
+                                return;
+                            }             		
+                        } catch ( java.text.ParseException e ) {
+                            // Ignore and move on
+                        }
+                    }
+                }
+                // Provide Etag based on Id and time if given.
+                // Ignore if not given. (Browser may cache if trivial ETag is given.)
+                if (entryETag != null) {
+                    response.addHeader(ETAG, entryETag );
+                }
+                if ( entryUpdated != null ) {
+                    response.addHeader(LASTMODIFIED, dateFormat.format( entryUpdated ));
+                }
+
+                // Content negotiation
+                String acceptType = request.getHeader( "Accept" );
+                String preferredType = getContentPreference( acceptType ); 
+                if (( preferredType != null ) && ((preferredType.indexOf( "json") > -1) || (preferredType.indexOf( "JSON") > -1 ))) {
+                    // JSON response body
+                    response.setContentType("application/json;type=entry");
+                    try {
+                        Abdera abdera = new Abdera();
+                        WriterFactory wf = abdera.getWriterFactory();
+                        org.apache.abdera.writer.Writer json = wf.getWriter("json");
+                        feedEntry.writeTo(json, response.getWriter());
+                    } catch (Exception e) {
+                        throw new ServletException(e);
+                    }           		
+                } else {
+                    // XML response body 
+                    response.setContentType("application/atom+xml;type=entry");
+                    try {
+                        feedEntry.writeTo(getWriter(response));
+                    } catch (IOException ioe) {
+                        throw new ServletException(ioe);
+                    }
+                }
+            } else {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            }
+        } else {
+            // Path doesn't match any known pattern
+            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+        }
+
+    }
+
+    protected Feed getFeed( HttpServletRequest request ) throws ServletException {
+        if (supportsFeedEntries) {
+            // The service implementation supports feed entries, invoke its getFeed operation
+            Message requestMessage = messageFactory.createMessage();
+            Message responseMessage;
+            if (request.getQueryString() != null) {
+                requestMessage.setBody(new Object[] {request.getQueryString()});
+                responseMessage = queryInvoker.invoke(requestMessage);
+            } else {
+                responseMessage = getFeedInvoker.invoke(requestMessage);
+            }
+            if (responseMessage.isFault()) {
+                throw new ServletException((Throwable)responseMessage.getBody());
+            }
+            return (Feed)responseMessage.getBody();		    
+        } else {
+
+            // The service implementation does not support feed entries,
+            // invoke its getAll operation to get the data item collection, then create
+            // feed entries from the items
+            Message requestMessage = messageFactory.createMessage();
+            Message responseMessage;
+            if (request.getQueryString() != null) {
+                requestMessage.setBody(new Object[] {request.getQueryString()});
+                responseMessage = queryInvoker.invoke(requestMessage);
+            } else {
+                responseMessage = getAllInvoker.invoke(requestMessage);
+            }
+            if (responseMessage.isFault()) {
+                throw new ServletException((Throwable)responseMessage.getBody());
+            }
+            Entry<Object, Object>[] collection = (Entry<Object, Object>[])responseMessage.getBody();
+            if (collection != null) {
+
+                // Create the feed
+                Feed feed = abderaFactory.newFeed();
+
+                // Set the feed title
+                if (title != null) {
+                    feed.setTitle(title);
+                } else {
+                    feed.setTitle("Feed");
+                }
+                if (description != null) {
+                    feed.setSubtitle(description);
+                }
+                // All feeds must provide Id and updated elements.
+                // However, some do not, so provide some program protection.
+                feed.setId( "Feed" + feed.hashCode());
+                Date responseLastModified = new Date( 0 );
+
+                // Add entries to the feed
+                for (Entry<Object, Object> entry: collection) {
+                    org.apache.abdera.model.Entry feedEntry = feedEntry(entry, itemClassType, itemXMLType, mediator, abderaFactory);
+                    // Use the most recent entry update as the feed update
+                    Date entryUpdated = feedEntry.getUpdated();
+                    if (( entryUpdated != null ) && (entryUpdated.compareTo( responseLastModified  ) > 0 )) {
+                        responseLastModified = entryUpdated;
+                    }
+                    feed.addEntry(feedEntry);
+                }
+                // If no entries were newly updated,
+                if ( responseLastModified.compareTo( new Date( 0 ) ) == 0 ) {
+                    responseLastModified = new Date();
+                }
+                return feed;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
+    IOException {
+        // Authenticate the user
+        String user = processAuthorizationHeader(request);
+        if (user == null) {
+            unauthorized(response);
+            return;
+        }
+
+        // Get the request path
+        String path = URLDecoder.decode(HTTPUtil.getRequestPath(request), "UTF-8");
+
+        if (path == null || path.length() == 0 || path.equals("/")) {
+            org.apache.abdera.model.Entry createdFeedEntry = null;
+
+            // Create a new Atom entry
+            String contentType = request.getContentType();
+            if (contentType != null && contentType.startsWith("application/atom+xml")) {
+
+                // Read the entry from the request
+                org.apache.abdera.model.Entry feedEntry;
+                try {
+                    Document<org.apache.abdera.model.Entry> doc = abderaParser.parse(request.getReader());
+                    feedEntry = doc.getRoot();
+                } catch (ParseException pe) {
+                    throw new ServletException(pe);
+                }
+
+                // Let the component implementation create it
+                if (supportsFeedEntries) {
+
+                    // The service implementation supports feed entries, pass the entry to it
+                    Message requestMessage = messageFactory.createMessage();
+                    requestMessage.setBody(new Object[] {feedEntry});
+                    Message responseMessage = postInvoker.invoke(requestMessage);
+                    if (responseMessage.isFault()) {
+                        throw new ServletException((Throwable)responseMessage.getBody());
+                    }
+                    createdFeedEntry = responseMessage.getBody();
+                } else {
+
+                    // The service implementation does not support feed entries, pass the data item to it
+                    Message requestMessage = messageFactory.createMessage();
+                    Entry<Object, Object> entry = entry(feedEntry, itemClassType, itemXMLType, mediator);
+                    requestMessage.setBody(new Object[] {entry.getKey(), entry.getData()});
+                    Message responseMessage = postInvoker.invoke(requestMessage);
+                    if (responseMessage.isFault()) {
+                        throw new ServletException((Throwable)responseMessage.getBody());
+                    }
+                    entry.setKey(responseMessage.getBody());
+                    createdFeedEntry = feedEntry(entry, itemClassType, itemXMLType, mediator, abderaFactory);
+                }
+
+            } else if (contentType != null) {
+                // Create a new media entry
+
+                // Get incoming headers
+                String title = request.getHeader("Title");
+                String slug = request.getHeader("Slug");
+
+                // Let the component implementation create the media entry
+                Message requestMessage = messageFactory.createMessage();
+                requestMessage.setBody(new Object[] {title, slug, contentType, request.getInputStream()});
+                Message responseMessage = postMediaInvoker.invoke(requestMessage);
+                if (responseMessage.isFault()) {
+                    throw new ServletException((Throwable)responseMessage.getBody());
+                }
+                createdFeedEntry = responseMessage.getBody();
+
+                // Transfer media info to response header.
+                // Summary is a comma separated list of header properties.
+                String summary = createdFeedEntry.getSummary();
+                addPropertiesToHeader( response, summary );
+
+            } else {
+                response.sendError(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
+            }
+
+            // A new entry for non-media was created successfully.
+            if (createdFeedEntry != null) {
+                // Set location of the created entry in the Location header
+                IRI feedId = createdFeedEntry.getId();
+                if ( feedId != null ) {
+                    response.addHeader(ETAG, "\"" + feedId.toString() + "\"" );
+                }
+                Date entryUpdated = createdFeedEntry.getUpdated();
+                if ( entryUpdated != null ) {
+                    response.addHeader(LASTMODIFIED, dateFormat.format( entryUpdated ));
+                }
+                Link link = createdFeedEntry.getSelfLink();
+                if (link != null) {
+                    response.addHeader(LOCATION, link.getHref().toString());
+                } 
+                Link editLink = createdFeedEntry.getEditLink();
+                if (editLink != null) {
+                    response.addHeader(LOCATION, editLink.getHref().toString());
+                }
+                Link editMediaLink = createdFeedEntry.getEditMediaLink();
+                if (editMediaLink != null) {
+                    response.addHeader(CONTENTLOCATION, editMediaLink.getHref().toString());
+                }
+
+                // Write the created Atom entry
+                response.setStatus(HttpServletResponse.SC_CREATED);
+                response.setContentType("application/atom+xml;type=entry");
+                try {
+                    createdFeedEntry.writeTo(getWriter(response));
+                } catch (ParseException pe) {
+                    throw new ServletException(pe);
+                }
+
+            } else {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            }
+
+        } else {
+            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+        }
+    }
+
+    private Writer getWriter(HttpServletResponse response) throws UnsupportedEncodingException, IOException {
+        Writer writer = new OutputStreamWriter(response.getOutputStream(), "UTF-8");
+        return writer;
+    }
+
+    @Override
+    protected void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // Authenticate the user
+        String user = processAuthorizationHeader(request);
+        if (user == null) {
+            unauthorized(response);
+            return;
+        }
+
+        // Get the request path
+        String path = URLDecoder.decode(HTTPUtil.getRequestPath(request), "UTF-8");
+
+        if (path != null && path.startsWith("/")) {
+            String id = path.substring(1);
+
+            // Update an Atom entry
+            String contentType = request.getContentType();
+            if (contentType != null && contentType.startsWith("application/atom+xml")) {
+
+                // Read the entry from the request
+                org.apache.abdera.model.Entry feedEntry;
+                try {
+                    Document<org.apache.abdera.model.Entry> doc = abderaParser.parse(request.getReader());
+                    feedEntry = doc.getRoot();
+                } catch (ParseException pe) {
+                    throw new ServletException(pe);
+                }
+
+                // Let the component implementation create it
+                if (supportsFeedEntries) {
+                    // The service implementation supports feed entries, pass the entry to it
+                    Message requestMessage = messageFactory.createMessage();
+                    requestMessage.setBody(new Object[] {id, feedEntry});
+                    Message responseMessage = putInvoker.invoke(requestMessage);
+                    if (responseMessage.isFault()) {
+                        Object body = responseMessage.getBody();
+                        if (body.getClass().getName().endsWith(".NotFoundException")) {
+                            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+                        } else {
+                            throw new ServletException((Throwable)responseMessage.getBody());
+                        }
+                    }
+                } else {
+                    // The service implementation does not support feed entries, pass the data item to it
+                    Message requestMessage = messageFactory.createMessage();
+                    Entry<Object, Object> entry = entry(feedEntry, itemClassType, itemXMLType, mediator);
+                    requestMessage.setBody(new Object[] {entry.getKey(), entry.getData()});
+                    Message responseMessage = putInvoker.invoke(requestMessage);
+                    if (responseMessage.isFault()) {
+                        Object body = responseMessage.getBody();
+                        if (body.getClass().getName().endsWith(".NotFoundException")) {
+                            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+                        } else {
+                            throw new ServletException((Throwable)responseMessage.getBody());
+                        }
+                    }
+                }
+
+            } else if (contentType != null) {
+
+                // Update a media entry
+
+                // Let the component implementation create the media entry
+                Message requestMessage = messageFactory.createMessage();
+                requestMessage.setBody(new Object[] {id, contentType, request.getInputStream()});
+                Message responseMessage = putMediaInvoker.invoke(requestMessage);
+
+                Object body = responseMessage.getBody();
+                if (responseMessage.isFault()) {
+                    if (body.getClass().getName().endsWith(".NotFoundException")) {
+                        response.sendError(HttpServletResponse.SC_NOT_FOUND);
+                    } else {
+                        throw new ServletException((Throwable)responseMessage.getBody());
+                    }
+                }
+
+                // Transfer content to response header.
+
+            } else {
+                response.sendError(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
+            }
+        } else {
+            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+        }
+    }
+
+    @Override
+    protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException,  IOException {
+
+        // Authenticate the user
+        String user = processAuthorizationHeader(request);
+        if (user == null) {
+            unauthorized(response);
+            return;
+        }
+
+        // Get the request path
+        String path = URLDecoder.decode(HTTPUtil.getRequestPath(request), "UTF-8");
+
+        String id;
+        if (path != null && path.startsWith("/")) {
+            id = path.substring(1);
+        } else {
+            id = "";
+        }
+
+        // Delete a specific entry from the collection
+        Message requestMessage = messageFactory.createMessage();
+        requestMessage.setBody(new Object[] {id});
+        Message responseMessage = deleteInvoker.invoke(requestMessage);
+        if (responseMessage.isFault()) {
+            Object body = responseMessage.getBody();
+            if (body.getClass().getName().endsWith(".NotFoundException")) {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            } else {
+                throw new ServletException((Throwable)responseMessage.getBody());
+            }
+        }
+    }
+    
+    /**
+     * Process the authorization header
+     * 
+     * @param request
+     * @return
+     * @throws ServletException
+     */
+    private String processAuthorizationHeader(HttpServletRequest request) throws ServletException {
+
+        // FIXME temporarily disabling this as it doesn't work with all browsers 
+        if (true)
+            return "admin";
+
+        try {
+            String authorization = request.getHeader("Authorization");
+            if (authorization != null) {
+                StringTokenizer tokens = new StringTokenizer(authorization);
+                if (tokens.hasMoreTokens()) {
+                    String basic = tokens.nextToken();
+                    if (basic.equalsIgnoreCase("Basic")) {
+                        String credentials = tokens.nextToken();
+                        String userAndPassword = new String(Base64.decodeBase64(credentials.getBytes()));
+                        int colon = userAndPassword.indexOf(":");
+                        if (colon != -1) {
+                            String user = userAndPassword.substring(0, colon);
+                            String password = userAndPassword.substring(colon + 1);
+
+                            // Authenticate the User.
+                            if (authenticate(user, password)) {
+                                return user;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new ServletException(e);
+        }
+        return null;
+    }
+
+    /**
+     * Authenticate a user.
+     * 
+     * @param user
+     * @param password
+     * @return
+     */
+    private boolean authenticate(String user, String password) {
+        // TODO Handle this using SCA security policies
+        return ("admin".equals(user) && "admin".equals(password));
+    }
+
+    /**
+     * Reject an unauthorized request.
+     * 
+     * @param response
+     */
+    private void unauthorized(HttpServletResponse response) throws IOException {
+        response.setHeader("WWW-Authenticate", "BASIC realm=\"Tuscany\"");
+        response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
+    }
+
+    /**
+     * Get content-type preference using application/atom-xml as default
+     * @param acceptType content-type preference using application/atom-xml as default
+     * @return
+     */
+    private static String getContentPreference( String acceptType ) {
+        if (( acceptType == null ) || ( acceptType.length() < 1 )) {
+            return "application/atom+xml";    		
+        }
+        StringTokenizer st = new StringTokenizer( acceptType, "," );
+        if ( st.hasMoreTokens() ) {
+            return st.nextToken(); 
+        }
+        return "application/atom+xml";
+    }
+
+    /** Take a list of key values and add them to the header.
+     * For instance "Content-Type=image/gif,Content-Length=14201"
+     * @param response
+     * @param properties
+     */
+    private static void addPropertiesToHeader( HttpServletResponse response, String properties  ) {
+        if ( properties == null ) return; 
+        StringTokenizer props = new StringTokenizer( properties, ",");
+        while( props.hasMoreTokens()) {
+            String prop = props.nextToken();
+            StringTokenizer keyVal = new StringTokenizer( prop, "=");
+            String key = null;
+            String val = null;
+            if ( keyVal.hasMoreTokens() )
+                key = keyVal.nextToken();
+            if ( keyVal.hasMoreTokens() )
+                val = keyVal.nextToken();
+            if (( key != null ) && ( val != null )) {
+                response.addHeader(key, val);                			
+            }
+        }
+    }
+
+    /**
+     * Round a date down to an exact number of seconds
+     * @param date with millisecond precision
+     * @return date rounded down to nearest second
+     */
+    private Date exactSeconds(Date date) {
+        return new Date(date.getTime() / 1000 * 1000);
+    }
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingProviderFactory.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingProviderFactory.java
new file mode 100644
index 0000000000..a160925e4e
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingProviderFactory.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import org.apache.tuscany.sca.binding.atom.AtomBinding;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.FactoryExtensionPoint;
+import org.apache.tuscany.sca.core.UtilityExtensionPoint;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.host.http.ServletHostHelper;
+import org.apache.tuscany.sca.invocation.MessageFactory;
+import org.apache.tuscany.sca.provider.BindingProviderFactory;
+import org.apache.tuscany.sca.provider.ReferenceBindingProvider;
+import org.apache.tuscany.sca.provider.ServiceBindingProvider;
+import org.apache.tuscany.sca.runtime.RuntimeEndpoint;
+import org.apache.tuscany.sca.runtime.RuntimeEndpointReference;
+
+/**
+ * Implementation of a Binding provider factory for the Atom binding.
+ *
+ * @version $Rev$ $Date$
+ */
+public class AtomBindingProviderFactory implements BindingProviderFactory<AtomBinding> {
+
+    private MessageFactory messageFactory;
+    private Mediator mediator;
+    private ServletHost servletHost;
+
+    public AtomBindingProviderFactory(ExtensionPointRegistry extensionPoints) {
+        this.servletHost = ServletHostHelper.getServletHost(extensionPoints);
+        FactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(FactoryExtensionPoint.class);
+        this.messageFactory = modelFactories.getFactory(MessageFactory.class);
+        this.mediator = extensionPoints.getExtensionPoint(UtilityExtensionPoint.class).getUtility(Mediator.class);
+    }
+
+    public ReferenceBindingProvider createReferenceBindingProvider(RuntimeEndpointReference endpointReference) {
+        return new AtomReferenceBindingProvider(endpointReference, mediator);
+    }
+
+    public ServiceBindingProvider createServiceBindingProvider(RuntimeEndpoint endpoint) {
+        return new AtomServiceBindingProvider(endpoint, messageFactory, mediator, servletHost);
+    }
+
+    public Class<AtomBinding> getModelType() {
+        return AtomBinding.class;
+    }
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingUtil.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingUtil.java
new file mode 100644
index 0000000000..ad1c8d2fd0
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomBindingUtil.java
@@ -0,0 +1,167 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import java.util.Date;
+
+import org.apache.abdera.factory.Factory;
+import org.apache.abdera.model.Content;
+import org.apache.abdera.model.Content.Type;
+import org.apache.abdera.model.Link;
+import org.apache.tuscany.sca.data.collection.Entry;
+import org.apache.tuscany.sca.data.collection.Item;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.interfacedef.DataType;
+
+/**
+ * Utility methods used in this package.
+ *
+ * @version $Rev$ $Date$
+ */
+class AtomBindingUtil {
+
+    /**
+     * Create a data item from an Atom entry.
+     * @param feedEntry
+     * @param itemClassType
+     * @param itemXMLType
+     * @param mediator
+     * @return
+     */
+    static Entry<Object, Object> entry(org.apache.abdera.model.Entry feedEntry,
+                                       DataType<?> itemClassType, DataType<?> itemXMLType, Mediator mediator) {
+        if (feedEntry != null) {
+            if (itemClassType.getPhysical() == Item.class || feedEntry.getContentType() == Type.HTML ) {
+                String key = feedEntry.getId().toString();
+
+                Item item = new Item();
+                item.setTitle(feedEntry.getTitle());
+                item.setContents(feedEntry.getContent());
+
+                for (Link link : feedEntry.getLinks()) {
+                    if (link.getRel() == null || "self".equals(link.getRel())) {
+                        if (item.getLink() == null) {
+                            item.setLink(link.getHref().toString());
+                        }
+                    } else if ("related".equals(link.getRel())) {
+                        item.setRelated(link.getHref().toString());
+                    } else if ("alternate".equals(link.getRel())) {
+                        item.setAlternate(link.getHref().toString());
+                    }
+                }
+
+                item.setDate(feedEntry.getUpdated());
+
+                return new Entry<Object, Object>(key, item);
+
+            } else {
+                String key = null; 
+                if ( feedEntry.getId() != null) {
+                    key = feedEntry.getId().toString();
+                }
+
+                // Create the item from XML
+                /*
+                if (feedEntry.getContentElement().getElements().size() == 0) {
+                    return null;
+                }
+                */
+
+                String value = feedEntry.getContent();
+                Object data = mediator.mediate(value, itemXMLType, itemClassType, null);
+
+                return new Entry<Object, Object>(key, data);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Create an Atom entry for a key and item from a collection.
+     * @param entry
+     * @param itemClassType
+     * @param itemXMLType
+     * @param mediator
+     * @param factory
+     * @return
+     */
+    static org.apache.abdera.model.Entry feedEntry(Entry<Object, Object> entry,
+                                  DataType<?> itemClassType, DataType<?> itemXMLType, Mediator mediator,
+                                  Factory factory) {
+        Object key = entry.getKey();
+        Object data = entry.getData();
+        if (data instanceof Item) {
+            Item item = (Item)data;
+
+            org.apache.abdera.model.Entry feedEntry = factory.newEntry();
+            if (key != null) {
+                feedEntry.setId(key.toString());
+            }
+            feedEntry.setTitle(item.getTitle());
+            feedEntry.setContentAsHtml(item.getContents());
+
+            String href = item.getLink();
+            if (href == null && key != null) {
+                href = key.toString();
+            }
+
+            if (href != null) {
+                feedEntry.addLink(href);
+            }
+            String related = item.getRelated();
+            if (related != null) {
+                feedEntry.addLink(related, "related");
+            }
+            String alternate = item.getAlternate();
+            if (alternate != null) {
+                feedEntry.addLink(alternate, "alternate");
+            }
+
+            Date date = item.getDate();
+            if (date != null) {
+                feedEntry.setUpdated(date);
+            }
+            return feedEntry;
+
+        } else if (data != null) {
+            org.apache.abdera.model.Entry feedEntry = factory.newEntry();
+            feedEntry.setId(key.toString());
+            feedEntry.setTitle("item");
+
+
+            // Convert the item to XML
+            String value = mediator.mediate(data, itemClassType, itemXMLType, null).toString();
+
+            Content content = factory.newContent();
+            content.setContentType(Content.Type.XML);
+            content.setValue(value);
+
+            feedEntry.setContentElement(content);
+
+            feedEntry.addLink(key.toString());
+
+            return feedEntry;
+        } else {
+            return null;
+        }
+    }
+    
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomReferenceBindingProvider.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomReferenceBindingProvider.java
new file mode 100644
index 0000000000..9f4ea496c1
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomReferenceBindingProvider.java
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import org.apache.http.client.HttpClient;
+import org.apache.tuscany.sca.assembly.EndpointReference;
+import org.apache.tuscany.sca.binding.atom.AtomBinding;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.host.http.client.HttpClientFactory;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.provider.ReferenceBindingProvider;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+
+/**
+ * Implementation of the Atom binding provider.
+ *
+ * @version $Rev$ $Date$
+ */
+class AtomReferenceBindingProvider implements ReferenceBindingProvider {
+    private EndpointReference endpointReference;
+    private RuntimeComponentReference reference;
+    private AtomBinding binding;
+    private String authorizationHeader = null;
+    private HttpClient httpClient;
+    private Mediator mediator;
+    private DataType<?> itemClassType;
+    private DataType<?> itemXMLType;
+    private boolean supportsFeedEntries;
+
+    /**
+     * Constructs a new AtomReferenceBindingProvider
+     * @param component
+     * @param reference
+     * @param binding
+     * @param mediator
+     */
+    AtomReferenceBindingProvider(EndpointReference endpointReference,
+                                 Mediator mediator) {
+        this.endpointReference = endpointReference;
+        this.reference = (RuntimeComponentReference) endpointReference.getReference();
+        this.binding = (AtomBinding) endpointReference.getBinding();
+        this.mediator = mediator;
+
+        // Prepare authorization header
+        // TUSCANY-3735: Don't send authorization header by default as this can cause problems.
+        // Commented out the following two lines until we have a better way to control this.
+        //String authorization = "admin" + ":" + "admin";
+        //authorizationHeader = "Basic " + new String(Base64.encodeBase64(authorization.getBytes()));
+
+    }
+
+    public Invoker createInvoker(Operation operation) {
+        
+        String operationName = operation.getName();            
+        if (operationName.equals("get")) { 
+
+            // Determine the collection item type
+            itemXMLType = new DataTypeImpl<Class<?>>(String.class.getName(), String.class, String.class);
+            DataType<XMLType> outputType = operation.getOutputType().getLogical().get(0);
+            itemClassType = outputType;
+            if (itemClassType.getPhysical() == org.apache.abdera.model.Entry.class) {
+                supportsFeedEntries = true;
+            }
+
+            return new AtomBindingInvoker.GetInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+
+        } else if (operationName.equals("post")) {
+            return new AtomBindingInvoker.PostInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("put")) {
+            return new AtomBindingInvoker.PutInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("delete")) {
+            return new AtomBindingInvoker.DeleteInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("getFeed") || operationName.equals("getAll")) {
+            return new AtomBindingInvoker.GetAllInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("postMedia")) {
+            return new AtomBindingInvoker.PostMediaInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("putMedia")) {
+            return new AtomBindingInvoker.PutMediaInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        } else if (operationName.equals("query")) {
+            return new AtomBindingInvoker.QueryInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+        }
+
+        return new AtomBindingInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+    }
+
+    public InterfaceContract getBindingInterfaceContract() {
+        return reference.getInterfaceContract();
+    }
+
+    public void start() {
+
+        // Configure the HTTP client credentials
+        // TUSCANY-3735: Don't use authentication by default as this can cause problems.
+        // Commented out the following four lines until we have a better way to control this.
+        //Credentials credentials = new UsernamePasswordCredentials("admin", "admin");
+        //httpClient.getParams().setAuthenticationPreemptive(true);
+        //URI uri = URI.create(binding.getURI());
+        //httpClient.getState().setCredentials(new AuthScope(uri.getHost(), uri.getPort()), credentials);
+
+        // Find the get operation on the reference interface
+        // Create an HTTP client
+        HttpClientFactory clientFactory = new HttpClientFactory();
+        httpClient = clientFactory.createHttpClient();
+    }
+
+    public void stop() {
+        if (httpClient != null) {
+            httpClient.getConnectionManager().shutdown();
+        }    	
+    }
+    
+    public boolean supportsOneWayInvocation() {
+        return false;
+    }
+
+    /**
+     * Returns the mediator.
+     * @return
+     */
+    Mediator getMediator() {
+        return mediator;
+    }
+
+    /**
+     * Returns the item class type.
+     * @return
+     */
+    DataType<?> getItemClassType() {
+        return itemClassType;
+    }
+
+    /**
+     * Returns the item XML type.
+     * @return
+     */
+    DataType<?> getItemXMLType() {
+        return itemXMLType;
+    }
+    
+    /**
+     * Returns true if the invoker should work with Atom
+     * feed entries.
+     * @return
+     */
+    boolean supportsFeedEntries() {
+        return supportsFeedEntries;
+    }
+
+}
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomServiceBindingProvider.java b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomServiceBindingProvider.java
new file mode 100644
index 0000000000..bc8149a67a
--- /dev/null
+++ b/sca-java-2.x/branches/2.0-Beta2/modules/binding-atom-runtime/src/main/java/org/apache/tuscany/sca/binding/atom/provider/AtomServiceBindingProvider.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.atom.provider;
+
+import org.apache.tuscany.sca.binding.atom.AtomBinding;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.invocation.MessageFactory;
+import org.apache.tuscany.sca.provider.ServiceBindingProvider;
+import org.apache.tuscany.sca.runtime.Invocable;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+import org.apache.tuscany.sca.runtime.RuntimeEndpoint;
+
+/**
+ * Implementation of the Atom binding provider.
+ *
+ * @version $Rev$ $Date$
+ */
+class AtomServiceBindingProvider implements ServiceBindingProvider {
+    private MessageFactory messageFactory;
+
+    private RuntimeEndpoint endpoint;
+
+    private RuntimeComponent component;
+    private RuntimeComponentService service;
+    private InterfaceContract serviceContract;
+    private AtomBinding binding;
+    private ServletHost servletHost;
+    private Mediator mediator;
+    
+    private String servletMapping;
+    private String bindingURI;
+
+    AtomServiceBindingProvider(RuntimeEndpoint endpoint,
+                               MessageFactory messageFactory,
+                               Mediator mediator,
+                               ServletHost servletHost) {
+        this.endpoint = endpoint;
+        this.component = (RuntimeComponent)endpoint.getComponent();
+        this.service = (RuntimeComponentService)endpoint.getService();
+        this.binding = (AtomBinding) endpoint.getBinding();
+
+        this.servletHost = servletHost;
+        this.messageFactory = messageFactory;
+        this.mediator = mediator;
+
+        // TUSCANY-3166
+        this.serviceContract = endpoint.getComponentTypeServiceInterfaceContract();
+    }
+
+    public InterfaceContract getBindingInterfaceContract() {
+        return serviceContract;
+    }
+    
+    public boolean supportsOneWayInvocation() {
+        return false;
+    }
+
+    public void start() {
+        Invocable wire = (RuntimeEndpoint) endpoint;
+
+        AtomBindingListenerServlet servlet =
+            new AtomBindingListenerServlet(wire, messageFactory, mediator, binding.getTitle(), binding.getDescription());
+
+        servletMapping = binding.getURI();
+        if (!servletMapping.endsWith("/")) {
+            servletMapping += "/";
+        }
+        if (!servletMapping.endsWith("*")) {
+            servletMapping += "*";
+        }
+        servletHost.addServletMapping(servletMapping, servlet);
+        
+        bindingURI = binding.getURI();
+        if (!bindingURI.endsWith("/")) {
+            bindingURI += "/";
+        }
+
+        String mappedURI = servletHost.addServletMapping(bindingURI, servlet);
+        String deployedURI = mappedURI;
+        if (deployedURI.endsWith("*")) {
+            deployedURI = deployedURI.substring(0, deployedURI.length() - 1);
+        }
+        if (deployedURI.endsWith("/")) {
+            deployedURI = deployedURI.substring(0, deployedURI.length() - 1);
+        }
+        binding.setURI(deployedURI);
+    }
+
+    public void stop() {
+        servletHost.removeServletMapping(servletMapping);
+        servletHost.removeServletMapping(bindingURI);
+    }
+}