TUSCANY-2458 TUSCANY-2460 - Initial patches for GData Binding from Haibo Zao

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

11 files changed, 2386 insertions, 0 deletions

diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/Collection.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/Collection.java
new file mode 100644
index 0000000000..d6e5d7c423
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/Collection.java
@@ -0,0 +1,78 @@
+/*
+ * 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.gdata.collection;
+
+import com.google.gdata.data.Entry;
+import com.google.gdata.data.Feed;
+import org.osoa.sca.annotations.Remotable;
+
+/**
+ * Provides access to a collection of resources using Gdata.
+ */
+@Remotable
+public interface Collection {
+
+    /**
+     * Get a GData feed for a collection of resources.
+     * 
+     * @return the GData feed
+     */
+    Feed getFeed();
+
+    /**
+     * Get a GData feed for a collection of resources resulting from a query.
+     * 
+     * @param queryString a query string
+     * @return the GData 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/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/MediaCollection.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/MediaCollection.java
new file mode 100644
index 0000000000..31e16e5f56
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/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.gdata.collection;
+
+import java.io.InputStream;
+
+import org.osoa.sca.annotations.Remotable; // import
+                                            // org.apache.abdera.model.Entry;
+
+import com.google.gdata.data.Entry;
+
+/**
+ * Provides access to a collection of resources using Atom.
+ */
+@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/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/NotFoundException.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/collection/NotFoundException.java
new file mode 100644
index 0000000000..4fc32d4d37
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/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.gdata.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/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingInvoker.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingInvoker.java
new file mode 100644
index 0000000000..04f72f548a
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingInvoker.java
@@ -0,0 +1,707 @@
+/*
+ * 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.gdata.provider;
+
+import static org.apache.tuscany.sca.binding.gdata.provider.GdataBindingUtil.entry;
+import static org.apache.tuscany.sca.binding.gdata.provider.GdataBindingUtil.feedEntry;
+
+import java.io.InputStreamReader;
+import java.io.StringWriter;
+import java.net.URL;
+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.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.URIException;
+import org.apache.commons.httpclient.methods.DeleteMethod;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.PutMethod;
+import org.apache.commons.httpclient.methods.StringRequestEntity;
+import org.apache.tuscany.sca.binding.gdata.collection.NotFoundException;
+import org.apache.tuscany.sca.data.collection.Entry;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.DataExchangeSemantics;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.osoa.sca.ServiceRuntimeException;
+
+import com.google.gdata.data.ExtensionProfile;
+import com.google.gdata.data.ParseSource;
+import com.google.gdata.data.TextContent;
+
+/**
+ * Invoker for the GData binding.
+ * 
+ */
+class GdataBindingInvoker implements Invoker, DataExchangeSemantics {
+
+    private static final Factory abderaFactory = Abdera.getNewFactory();
+    private static final Parser abderaParser = Abdera.getNewParser();
+
+    Operation operation;
+    String uri;
+    HttpClient httpClient;
+    String authorizationHeader;
+    GdataReferenceBindingProvider provider;
+
+    private static final com.google.gdata.client.GoogleService googleService =
+        new com.google.gdata.client.GoogleService("cl", "exampleCo-exampleApp-1");
+
+    GdataBindingInvoker(Operation operation,
+                        String uri,
+                        HttpClient httpClient,
+                        String authorizationHeader,
+                        GdataReferenceBindingProvider bindingProvider) {
+        this.operation = operation;
+        this.uri = uri;
+        this.httpClient = httpClient;
+        this.authorizationHeader = authorizationHeader;
+        this.provider = bindingProvider;
+        // this.googleService = new com.google.gdata.client.GoogleService("cl",
+        // "exampleCo-exampleApp-1");
+
+        // //System.out.println("GdataBindingInvoker constuctor reached!: " +
+        // operation);
+    }
+
+    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 GdataBindingInvoker {
+        public GetInvoker(Operation operation,
+                          String uri,
+                          HttpClient httpClient,
+                          String authorizationHeader,
+                          GdataReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+
+            System.out.println("GdataBindingInvoker.GetInvoker.invoke is reached!");
+
+            // Get an entry
+            String id = (String)((Object[])msg.getBody())[0];
+
+            System.out.println("GdataBindingInvoker.GetInvoker.invoke---id: " + id);
+
+            // Send an HTTP GET
+            GetMethod getMethod = new GetMethod(uri + "/" + id);
+            getMethod.setRequestHeader("Authorization", authorizationHeader);
+
+            try {
+                System.out.println("GdataBindingInvoker.GetInvoker.invoke---feedURL: " + getMethod.getURI().toString());
+            } catch (URIException e1) {
+                // TODO Auto-generated catch block
+                e1.printStackTrace();
+            }
+
+            boolean parsing = false;
+            try {
+                httpClient.executeMethod(getMethod);
+                int status = getMethod.getStatusCode();
+
+                System.out.println("GdataBindingInvoker.GetInvoker.invoke---I am good here00");
+                System.out.println("GdataBindingInvoker.GetInvoker.invoke---status: " + status);
+
+                // Read the Atom entry
+                if (status == 200) {
+
+                    URL feedURL = new URL(getMethod.getURI().toString());
+
+                    System.out.println("GdataBindingInvoker.GetInvoker.invoke---feedURL: " + feedURL);
+
+                    com.google.gdata.data.Entry entry =
+                        googleService.getEntry(feedURL, com.google.gdata.data.Entry.class);
+
+                    System.out.println("GetInvoker class:   I am good here 04");
+
+                    System.out.println("entry title: " + entry.getTitle().getPlainText());
+
+                    System.out.println("GdataBindingInvoker.GetInvoker.invoke---entry");
+
+                    // Document<Feed> doc = abderaParser.parse(new
+                    // InputStreamReader(getMethod.getResponseBodyAsStream()));
+                    // parsing = true;
+                    // Feed feed = doc.getRoot();
+
+                    // System.out.println("getMethod.getResponseBodyAsString()"
+                    // + getMethod.getResponseBodyAsString());
+
+                    // feed = (com.google.gdata.data.Feed)
+                    // responseMessage.getBody();
+
+                    System.out.println("provider.supportsFeedEntries()" + provider.supportsFeedEntries());
+
+                    if (provider.supportsFeedEntries()) {
+
+                        // Return the Atom entry
+                        msg.setBody(entry);
+
+                    } 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());
+                    }
+
+                    // To-change
+                    // This is read the entries from the response body
+                    // Change it into the corresponding Gdata parse and populate
+                    // the message with entries.
+
+                } else if (status == 404) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                if (!parsing) {
+                    // Release the connection unless the Abdera parser is
+                    // parsing the response, in this case it will release it
+                    getMethod.releaseConnection();
+                }
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Post operation invoker
+     */
+    public static class PostInvoker extends GdataBindingInvoker {
+
+        public PostInvoker(Operation operation,
+                           String uri,
+                           HttpClient httpClient,
+                           String authorizationHeader,
+                           GdataReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+
+            System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- Constructor method reached");
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+
+            System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- invoke method reached");
+            // Post an entry
+            Object[] args = (Object[])msg.getBody();
+            com.google.gdata.data.Entry feedEntry = null;
+
+            if (provider.supportsFeedEntries()) {
+
+                // Expect an Atom entry
+
+                // To-change
+                // Expect a Gdata entry
+                // change it into com.google.gdata.data.Entry
+
+                System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- supportsFeedEntries: " + provider
+                    .supportsFeedEntries());
+                feedEntry = (com.google.gdata.data.Entry)args[0];
+
+                System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- feedEntry title: " + feedEntry
+                    .getTitle().getPlainText());
+
+            } else {
+                // Expect a key and data item
+                Entry<Object, Object> entry = new Entry<Object, Object>(args[0], args[1]);
+                // FIXME: this needs to be fixed
+                // feedEntry = feedEntry(entry, provider.getItemClassType(),
+                // provider.getItemXMLType(), provider.getMediator(),
+                // abderaFactory);
+            }
+
+            // Send an HTTP POST
+            PostMethod postMethod = new PostMethod(uri);
+
+            System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- uri: " + uri);
+
+            postMethod.setRequestHeader("Authorization", authorizationHeader);
+            boolean parsing = false;
+            try {
+                // Write the Atom entry
+                // StringWriter writer = new StringWriter();
+                // feedEntry.writeTo(writer);
+
+                StringWriter writer = new StringWriter();
+                com.google.gdata.util.common.xml.XmlWriter w = new com.google.gdata.util.common.xml.XmlWriter(writer);
+                feedEntry.generateAtom(w, new ExtensionProfile());
+                w.flush();
+
+                postMethod.setRequestHeader("Content-type", "application/atom+xml; charset=utf-8");
+                postMethod.setRequestEntity(new StringRequestEntity(writer.toString()));
+
+                httpClient.executeMethod(postMethod);
+                int status = postMethod.getStatusCode();
+
+                System.out.println("[Debug Info]GdataBindingInvoker.PostInvoker --- status code: " + status);
+
+                // Read the Atom entry
+                if (status == 200 || status == 201) {
+
+                    /*
+                     * Document<org.apache.abdera.model.Entry> doc =
+                     * abderaParser.parse(new
+                     * InputStreamReader(postMethod.getResponseBodyAsStream()));
+                     * parsing = true; org.apache.abdera.model.Entry
+                     * createdEntry = doc.getRoot();
+                     */
+
+                    ParseSource source = new ParseSource(new InputStreamReader(postMethod.getResponseBodyAsStream()));
+                    com.google.gdata.data.Entry createdEntry =
+                        com.google.gdata.data.Entry.readEntry(source, com.google.gdata.data.Entry.class, null);
+
+                    System.out.println("parsed createdentry title: " + createdEntry.getTitle().getPlainText());
+                    System.out.println("parsed createdentry content: " + ((TextContent)createdEntry.getContent())
+                        .getContent().getPlainText());
+                    System.out.println("parsed createdentry updated: " + createdEntry.getUpdated().toString());
+
+                    /*
+                     * Document<org.apache.abdera.model.Entry> doc =
+                     * abderaParser.parse(new
+                     * InputStreamReader(postMethod.getResponseBodyAsStream()));
+                     * 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());
+                    }
+
+                    // To-change
+                    // Get the status back and parse the updated entry
+                    // Need to change it into the corresponding Gdata Entry
+                    // class
+
+                } else if (status == 404) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                if (!parsing) {
+                    // Release the connection unless the Abdera parser is
+                    // parsing the response, in this case it will release it
+                    postMethod.releaseConnection();
+                }
+            }
+
+            return msg;
+        }
+    }
+
+    // To-change
+    // For the following classes: PutInvoker, DeleteInvoker, GetAllInvoker,
+    // PostMediaInvoker and PutMediaInvoker
+    // We just need to modify the corresponding parser and entry methods for
+    // Gdata
+    // The key point is the data conversion from item and gdata entry
+    // and parsing and writing entries in message
+    //
+
+    /**
+     * Put operation invoker
+     */
+    public static class PutInvoker extends GdataBindingInvoker {
+
+        public PutInvoker(Operation operation,
+                          String uri,
+                          HttpClient httpClient,
+                          String authorizationHeader,
+                          GdataReferenceBindingProvider 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
+            PutMethod putMethod = new PutMethod(uri + "/" + id);
+            putMethod.setRequestHeader("Authorization", authorizationHeader);
+            try {
+
+                // Write the Atom entry
+                StringWriter writer = new StringWriter();
+                feedEntry.writeTo(writer);
+                putMethod.setRequestHeader("Content-type", "application/atom+xml; charset=utf-8");
+                putMethod.setRequestEntity(new StringRequestEntity(writer.toString()));
+
+                httpClient.executeMethod(putMethod);
+                int status = putMethod.getStatusCode();
+                if (status == 200 || status == 201) {
+
+                    msg.setBody(null);
+
+                } else if (status == 404) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                putMethod.releaseConnection();
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Delete operation invoker
+     */
+    public static class DeleteInvoker extends GdataBindingInvoker {
+
+        public DeleteInvoker(Operation operation,
+                             String uri,
+                             HttpClient httpClient,
+                             String authorizationHeader,
+                             GdataReferenceBindingProvider 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
+            DeleteMethod deleteMethod = new DeleteMethod(uri + "/" + id);
+            deleteMethod.setRequestHeader("Authorization", authorizationHeader);
+            try {
+                httpClient.executeMethod(deleteMethod);
+                int status = deleteMethod.getStatusCode();
+                if (status == 200) {
+                    msg.setBody(null);
+
+                } else if (status == 404) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                deleteMethod.releaseConnection();
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * GetAll operation invoker
+     */
+    public static class GetAllInvoker extends GdataBindingInvoker {
+
+        public GetAllInvoker(Operation operation,
+                             String uri,
+                             HttpClient httpClient,
+                             String authorizationHeader,
+                             GdataReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+
+            // Get a feed
+            System.out.println("GetAllInvoker class:   I am good here 00");
+
+            // Send an HTTP GET
+            GetMethod getMethod = new GetMethod(uri);
+            getMethod.setRequestHeader("Authorization", authorizationHeader);
+
+            System.out.println("GetAllInvoker class:   I am good here 01");
+
+            try {
+                System.out.println("GdataBindingInvoker.GetAllInvoker.invoke---feedURL: " + getMethod.getURI()
+                    .toString());
+            } catch (URIException e1) {
+                // TODO Auto-generated catch block
+                e1.printStackTrace();
+            }
+
+            boolean parsing = false;
+            try {
+
+                System.out.println("GetAllInvoker class:   I am good here 02");
+
+                httpClient.executeMethod(getMethod);
+                int status = getMethod.getStatusCode();
+
+                System.out.println("GetAllInvoker class:   I am good here 03");
+
+                // Read the Atom feed
+                if (status == 200) {
+
+                    URL feedURL = new URL(getMethod.getURI().toString());
+
+                    System.out.println("GdataBindingInvoker.GetInvoker.invoke---feedURL: " + feedURL);
+
+                    /*
+                     * //Changed by Haibo System.out.println("feedURL.toString: " +
+                     * feedURL.toString()); InputStreamReader stringReader= new
+                     * InputStreamReader(getMethod.getResponseBodyAsStream());
+                     * StringBuffer buffer = new StringBuffer(); Reader in = new
+                     * BufferedReader(stringReader); XhtmlTextConstruct
+                     * construct = new XhtmlTextConstruct();
+                     * com.google.gdata.data.XhtmlTextConstruct.AtomHandler
+                     * rootHandler = construct.new AtomHandler(); XmlParser
+                     * parser = new XmlParser();
+                     * parser.parse(in,rootHandler,"http://www.w3.org/2005/Atom","feed");
+                     * System.out.println(construct.getXhtml().getBlob());
+                     */
+
+                    com.google.gdata.data.Feed feed = googleService.getFeed(feedURL, com.google.gdata.data.Feed.class);
+
+                    System.out.println("GetAllInvoker class:   I am good here 04");
+
+                    System.out.println("feed title: " + feed.getTitle().getPlainText());
+
+                    // Document<Feed> doc = abderaParser.parse(new
+                    // InputStreamReader(getMethod.getResponseBodyAsStream()));
+                    // parsing = true;
+                    // Feed feed = doc.getRoot();
+
+                    // System.out.println("getMethod.getResponseBodyAsString()"
+                    // + getMethod.getResponseBodyAsString());
+
+                    // feed = (com.google.gdata.data.Feed)
+                    // responseMessage.getBody();
+
+                    System.out.println("provider.supportsFeedEntries()" + provider.supportsFeedEntries());
+
+                    if (provider.supportsFeedEntries()) {
+
+                        System.out.println("GetAllInvoker class:   I am good here 05");
+
+                        // Returns the Atom feed
+                        msg.setBody(feed);
+
+                        System.out.println("msg: " + msg.toString());
+
+                    } 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) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                if (!parsing) {
+                    // Release the connection unless the Abdera parser is
+                    // parsing the response, in this case it will release it
+                    getMethod.releaseConnection();
+                }
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * Query operation invoker
+     */
+    public static class QueryInvoker extends GdataBindingInvoker {
+
+        public QueryInvoker(Operation operation,
+                            String uri,
+                            HttpClient httpClient,
+                            String authorizationHeader,
+                            GdataReferenceBindingProvider 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
+            GetMethod getMethod = new GetMethod(uri);
+            getMethod.setRequestHeader("Authorization", authorizationHeader);
+            getMethod.setQueryString(queryString);
+            boolean parsing = false;
+            try {
+                httpClient.executeMethod(getMethod);
+                int status = getMethod.getStatusCode();
+
+                // Read the Atom feed
+                if (status == 200) {
+                    Document<Feed> doc = abderaParser.parse(new InputStreamReader(getMethod.getResponseBodyAsStream()));
+                    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) {
+                    msg.setFaultBody(new NotFoundException());
+                } else {
+                    msg.setFaultBody(new ServiceRuntimeException("HTTP status code: " + status));
+                }
+
+            } catch (Exception e) {
+                msg.setFaultBody(new ServiceRuntimeException(e));
+            } finally {
+                if (!parsing) {
+                    // Release the connection unless the Abdera parser is
+                    // parsing the response, in this case it will release it
+                    getMethod.releaseConnection();
+                }
+            }
+
+            return msg;
+        }
+    }
+
+    /**
+     * PostMedia operation invoker
+     */
+    public static class PostMediaInvoker extends GdataBindingInvoker {
+
+        public PostMediaInvoker(Operation operation,
+                                String uri,
+                                HttpClient httpClient,
+                                String authorizationHeader,
+                                GdataReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // TODO implement
+            return super.invoke(msg);
+        }
+    }
+
+    /**
+     * PutMedia operation invoker
+     */
+    public static class PutMediaInvoker extends GdataBindingInvoker {
+
+        public PutMediaInvoker(Operation operation,
+                               String uri,
+                               HttpClient httpClient,
+                               String authorizationHeader,
+                               GdataReferenceBindingProvider bindingProvider) {
+            super(operation, uri, httpClient, authorizationHeader, bindingProvider);
+        }
+
+        @Override
+        public Message invoke(Message msg) {
+            // TODO implement
+            return super.invoke(msg);
+        }
+    }
+
+    public boolean allowsPassByReference() {
+        // TODO Auto-generated method stub
+        return true;
+    }
+
+}
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingListenerServlet.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingListenerServlet.java
new file mode 100644
index 0000000000..e287b5b0df
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingListenerServlet.java
@@ -0,0 +1,724 @@
+/*
+ * 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.gdata.provider;
+
+import static org.apache.tuscany.sca.binding.gdata.provider.GdataBindingUtil.entry;
+import static org.apache.tuscany.sca.binding.gdata.provider.GdataBindingUtil.feedEntry;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import java.io.Writer;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+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 javax.xml.namespace.QName;
+
+import org.apache.abdera.Abdera;
+import org.apache.abdera.factory.Factory;
+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.commons.codec.binary.Base64;
+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.interfacedef.util.XMLType;
+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.RuntimeWire;
+
+import com.google.gdata.data.ExtensionProfile;
+import com.google.gdata.data.ParseSource;
+import com.google.gdata.data.PlainTextConstruct;
+import com.google.gdata.util.ServiceException;
+
+/**
+ * A resource collection binding listener, implemented as a Servlet and
+ * registered in a Servlet host provided by the SCA hosting runtime.
+ */
+class GdataBindingListenerServlet extends HttpServlet {
+    private static final Logger logger = Logger.getLogger(GdataBindingListenerServlet.class.getName());
+    private static final long serialVersionUID = 1L;
+
+    private static final Factory abderaFactory = Abdera.getNewFactory();
+    private static final Parser abderaParser = Abdera.getNewParser();
+
+    private RuntimeWire 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 Mediator mediator;
+    private DataType<?> itemClassType;
+    private DataType<?> itemXMLType;
+    private boolean supportsFeedEntries;
+
+    /**
+     * Constructs a new binding listener.
+     * 
+     * @param wire
+     * @param messageFactory
+     * @param feedType
+     */
+    GdataBindingListenerServlet(RuntimeWire wire, MessageFactory messageFactory, Mediator mediator, String title) {
+        this.wire = wire;
+        this.messageFactory = messageFactory;
+        this.mediator = mediator;
+        this.title = title;
+
+        // 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")) {
+
+                System.out.println("[Debug Info]GdataBindingListenerServlet constructor --- operation: 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")) {
+                System.out.println("[Debug Info]GdataBindingListenerServlet Constructor --- opeartion: 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")) {
+
+                System.out.println("[Debug Info]GdataBindingListenerServlet Constructor --- opeartion: post");
+                postInvoker = invocationChain.getHeadInvoker();
+
+            } else if (operationName.equals("postMedia")) {
+                postMediaInvoker = invocationChain.getHeadInvoker();
+            } else if (operationName.equals("delete")) {
+                deleteInvoker = invocationChain.getHeadInvoker();
+            }
+        }
+
+        System.out.println("[Debug Info]GdataBindingListenerServlet constructor --- I am good here 00");
+
+        // Determine the collection item type
+        itemXMLType = new DataTypeImpl<Class<?>>(String.class.getName(), String.class, String.class);
+        Class<?> itemClass = getOperation.getOutputType().getPhysical();
+
+        // if (itemClass == org.apache.abdera.model.Entry.class) {
+        if (itemClass == com.google.gdata.data.Entry.class) {
+            supportsFeedEntries = true;
+        }
+        DataType<XMLType> outputType = getOperation.getOutputType();
+        QName qname = outputType.getLogical().getElementName();
+        qname = new QName(qname.getNamespaceURI(), itemClass.getSimpleName());
+        itemClassType = new DataTypeImpl<XMLType>("java:complexType", itemClass, new XMLType(qname, null));
+
+        System.out.println("[Debug Info]GdataBindingListenerServlet constructor --- initilized!");
+    }
+
+    @Override
+    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+
+        // No authentication required for a get request
+        System.out.println("[Debug Info]GdataBindingListenerServlet doGet() --- I am good here 00");
+
+        // Get the request path
+        String path = URLDecoder.decode(request.getRequestURI().substring(request.getServletPath().length()), "UTF-8");
+
+        System.out.println("[Debug Info]GdataBindingListenerServlet doGet() --- request.getRequestURI():  " + request
+            .getRequestURI());
+        System.out.println("[Debug Info]GdataBindingListenerServlet doGet()--- path: " + path);
+
+        // FIXME: Log this get http request, commented out for testing
+        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>
+             */
+
+            System.out.println("GdataBindingListenerServlet doGet(): I am good here brach 01");
+            // Return the Atom service document
+            response.setContentType("application/atomsvc+xml; charset=utf-8");
+
+            Service service = abderaFactory.newService();
+            // service.setText("service");
+
+            Workspace workspace = abderaFactory.newWorkspace();
+            workspace.setTitle("resource");
+
+            String href = request.getRequestURL().toString();
+            href = href.substring(0, href.length() - "/atomsvc".length());
+
+            Collection collection = workspace.addCollection("collection", "atom/feed");
+            collection.setTitle("entries");
+            collection.setAttributeValue("href", href);
+            collection.setAccept("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("/")) {
+
+            // get HTTP request asking for a feed
+
+            System.out.println("[Debug Info]GdataBindingListenerServlet doGet() --- I am good here brach 02");
+
+            // Return a feed containing the entries in the collection
+            com.google.gdata.data.Feed feed = null;
+
+            if (supportsFeedEntries) {
+
+                System.out
+                    .println("[Debug Info]GdataBindingListenerServlet doGet() --- supportsFeedEntries: " + supportsFeedEntries);
+
+                // The service implementation supports feed entries, invoke its
+                // getFeed operation
+                Message requestMessage = messageFactory.createMessage();
+                Message responseMessage;
+                if (request.getQueryString() != null) {
+                    System.out.println("getQueryString != null");
+                    requestMessage.setBody(new Object[] {request.getQueryString()});
+                    responseMessage = queryInvoker.invoke(requestMessage);
+                } else {
+                    System.out.println("getQueryString == null");
+                    responseMessage = getFeedInvoker.invoke(requestMessage);
+                }
+                if (responseMessage.isFault()) {
+                    throw new ServletException((Throwable)responseMessage.getBody());
+                }
+
+                System.out.println("response msg class:" + responseMessage.getBody().getClass());
+
+                feed = (com.google.gdata.data.Feed)responseMessage.getBody();
+
+                System.out.println("feed title: " + feed.getTitle().getPlainText());
+
+            } else {
+
+                System.out.println("GdataBindingListenerServlet doGet(): do not supportsFeedEntries");
+
+                // 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);
+
+                    System.out
+                        .println("GdataBindingListner.doGet(): get msg from getAllInvoker.invoke()" + responseMessage
+                            .getBody().toString());
+
+                }
+                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 = new com.google.gdata.data.Feed();
+
+                    // Set the feed title
+                    if (title != null) {
+                        feed.setTitle(new PlainTextConstruct(title));
+                    } else {
+                        feed.setTitle(new PlainTextConstruct("Feed title"));
+                    }
+
+                    // Add entries to the feed
+                    ArrayList<com.google.gdata.data.Entry> entries = new ArrayList<com.google.gdata.data.Entry>();
+                    for (Entry<Object, Object> entry : collection) {
+                        com.google.gdata.data.Entry feedEntry = feedEntry(entry, itemClassType, itemXMLType, mediator);
+                        entries.add(feedEntry);
+                    }
+                    feed.setEntries(entries);
+
+                }
+            }
+            if (feed != null) {
+
+                // //System.out.println("feed(from the http response)is not
+                // null");
+
+                // Write a GData feed using Atom representation
+                response.setContentType("application/atom+xml; charset=utf-8");
+
+                // Generate the corresponding Atom representation of the feed
+                StringWriter stringWriter = new StringWriter();
+                com.google.gdata.util.common.xml.XmlWriter w =
+                    new com.google.gdata.util.common.xml.XmlWriter(stringWriter);
+                feed.generateAtom(w, new ExtensionProfile());
+                w.flush();
+
+                // Write the Atom representation(XML) into Http response content
+                OutputStreamWriter osw = new OutputStreamWriter(response.getOutputStream());
+                PrintWriter out = new PrintWriter(response.getOutputStream());
+                out.println(stringWriter.toString());
+                out.close();
+
+                System.out.println("Feed content in plain text:" + stringWriter.toString());
+            } else {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            }
+
+        } else if (path.startsWith("/")) {
+
+            // get HTTP request asking for an entry
+
+            // Return a specific entry in the collection
+            com.google.gdata.data.Entry feedEntry = null;
+
+            // 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()) {
+                throw new ServletException((Throwable)responseMessage.getBody());
+            }
+
+            if (supportsFeedEntries) {
+                // The service implementation returns a feed entry
+                feedEntry = (com.google.gdata.data.Entry)responseMessage.getBody();
+
+                System.out.println("entry title: " + feedEntry.getTitle().getPlainText());
+
+            } 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());
+                // FIXME The line below needs to be fixed
+                // feedEntry = feedEntry(entry, itemClassType, itemXMLType,
+                // mediator, abderaFactory);
+            }
+
+            // Write the Atom entry
+            if (feedEntry != null) {
+
+                // Write a GData entry using Atom representation
+                response.setContentType("application/atom+xml; charset=utf-8");
+
+                // Generate the corresponding Atom representation of the feed
+                StringWriter stringWriter = new StringWriter();
+                com.google.gdata.util.common.xml.XmlWriter w =
+                    new com.google.gdata.util.common.xml.XmlWriter(stringWriter);
+                feedEntry.generateAtom(w, new ExtensionProfile());
+                w.flush();
+
+                // Write the Atom representation(XML) into Http response content
+                OutputStreamWriter osw = new OutputStreamWriter(response.getOutputStream());
+                PrintWriter out = new PrintWriter(response.getOutputStream());
+                out.println(stringWriter.toString());
+                out.close();
+
+            } else {
+                response.sendError(HttpServletResponse.SC_NOT_FOUND);
+            }
+        } else {
+            // Path doesn't match any known pattern
+            response.sendError(HttpServletResponse.SC_NOT_FOUND);
+        }
+
+    }
+
+    @Override
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
+        IOException {
+
+        System.out.println("[Debug Info]GdataBindingListenerServlet doPost() --- reached");
+
+        // Authenticate the user
+        String user = processAuthorizationHeader(request);
+        if (user == null) {
+            unauthorized(response);
+            return;
+        }
+
+        // Get the request path
+        String path = URLDecoder.decode(request.getRequestURI().substring(request.getServletPath().length()), "UTF-8");
+
+        System.out.println("[Debug Info]GdataBindingListenerServlet path --- " + path);
+
+        if (path == null || path.length() == 0 || path.equals("/")) {
+            // Create a new Gdata entry
+            com.google.gdata.data.Entry createdFeedEntry = null;
+            String contentType = request.getContentType();
+
+            if (contentType != null && contentType.startsWith("application/atom+xml")) {
+
+                // Read the entry from the request
+                com.google.gdata.data.Entry feedEntry = null;
+                try {
+                    ParseSource source = new ParseSource(request.getReader());
+                    feedEntry = com.google.gdata.data.Entry.readEntry(source, com.google.gdata.data.Entry.class, null);
+
+                    /*
+                     * Document<org.apache.abdera.model.Entry> doc =
+                     * abderaParser.parse(request.getReader()); feedEntry =
+                     * doc.getRoot();
+                     */
+                } catch (ParseException pe) {
+                    throw new ServletException(pe);
+
+                } catch (com.google.gdata.util.ParseException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                } catch (ServiceException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+
+                // 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);
+                }
+
+            } 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();
+            } else {
+                response.sendError(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
+            }
+
+            // A new entry was created successfully
+            if (createdFeedEntry != null) {
+
+                // Set location of the created entry in the Location header
+                // Link link = createdFeedEntry.getSelfLink();
+                // if (link != null) {
+                // response.addHeader("Location", link.getHref().toString());
+                // }
+
+                // Write the created Atom entry
+                response.setStatus(HttpServletResponse.SC_CREATED);
+                response.setContentType("application/atom+xml; charset=utf-8");
+                try {
+
+                    // Generate the corresponding Atom representation of the
+                    // feed
+                    StringWriter stringWriter = new StringWriter();
+                    com.google.gdata.util.common.xml.XmlWriter w =
+                        new com.google.gdata.util.common.xml.XmlWriter(stringWriter);
+                    createdFeedEntry.generateAtom(w, new ExtensionProfile());
+                    w.flush();
+
+                    // Write the Atom representation(XML) into Http response
+                    // content
+                    OutputStreamWriter osw = new OutputStreamWriter(response.getOutputStream());
+                    PrintWriter out = new PrintWriter(response.getOutputStream());
+                    out.println(stringWriter.toString());
+                    out.close();
+
+                } 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 = request.getRequestURI().substring(request.getServletPath().length());
+
+        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) {
+
+                // Updated 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());
+                    }
+                }
+            } 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(request.getRequestURI().substring(request.getServletPath().length()), "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);
+    }
+}
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingProviderFactory.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingProviderFactory.java
new file mode 100644
index 0000000000..765ba43039
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingProviderFactory.java
@@ -0,0 +1,73 @@
+/*
+ * 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.gdata.provider;
+
+import org.apache.tuscany.sca.binding.gdata.GdataBinding;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.databinding.Mediator;
+import org.apache.tuscany.sca.databinding.TransformerExtensionPoint;
+import org.apache.tuscany.sca.databinding.impl.MediatorImpl;
+import org.apache.tuscany.sca.host.http.ServletHost;
+import org.apache.tuscany.sca.host.http.ServletHostExtensionPoint;
+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.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+
+/**
+ * Implementation of a Binding provider factory for the Atom binding.
+ */
+public class GdataBindingProviderFactory implements BindingProviderFactory<GdataBinding> {
+
+    private MessageFactory messageFactory;
+    private Mediator mediator;
+    private ServletHost servletHost;
+
+    public GdataBindingProviderFactory(ExtensionPointRegistry extensionPoints) {
+        ServletHostExtensionPoint servletHosts = extensionPoints.getExtensionPoint(ServletHostExtensionPoint.class);
+        this.servletHost = servletHosts.getServletHosts().get(0);
+        ModelFactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(ModelFactoryExtensionPoint.class);
+        this.messageFactory = modelFactories.getFactory(MessageFactory.class);
+        this.mediator =
+            new MediatorImpl(extensionPoints.getExtensionPoint(DataBindingExtensionPoint.class), extensionPoints
+                .getExtensionPoint(TransformerExtensionPoint.class));
+    }
+
+    public ReferenceBindingProvider createReferenceBindingProvider(RuntimeComponent component,
+                                                                   RuntimeComponentReference reference,
+                                                                   GdataBinding binding) {
+        return new GdataReferenceBindingProvider(component, reference, binding, mediator);
+    }
+
+    public ServiceBindingProvider createServiceBindingProvider(RuntimeComponent component,
+                                                               RuntimeComponentService service,
+                                                               GdataBinding binding) {
+        return new GdataServiceBindingProvider(component, service, binding, servletHost, messageFactory, mediator);
+    }
+
+    public Class<GdataBinding> getModelType() {
+        return GdataBinding.class;
+    }
+}
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingUtil.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingUtil.java
new file mode 100644
index 0000000000..8f67594108
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataBindingUtil.java
@@ -0,0 +1,346 @@
+/*
+ * 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.gdata.provider;
+
+import java.util.Date;
+
+import org.apache.abdera.factory.Factory;
+import org.apache.abdera.model.Content;
+import org.apache.abdera.model.Link;
+
+// To-Change
+// import com.google.gdata.data.Entry;
+// import com.google.gdata.data.Feed;
+// import com.google.gdata.data.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;
+
+import com.google.gdata.data.DateTime;
+import com.google.gdata.data.PlainTextConstruct;
+import com.google.gdata.data.TextContent;
+
+/**
+ * Utility methods used in this package.
+ * 
+ */
+class GdataBindingUtil {
+
+    /**
+     * Create a data item from an Atom entry.
+     * 
+     * @param feedEntry
+     * @param itemClassType
+     * @param itemXMLType
+     * @param mediator
+     * @return
+     */
+    // To-Change: org.apache.abdera.model.Entry --> com.google.gdata.data.Entry
+    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) {
+                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);
+
+                // To-change
+                // Get feed information from feedEntry and create a new Entry
+                // For GDtata, the corresponding methods are different such as
+                // getTitle(), getContent(), getUpdated() and getLinks()
+                // I am going to use Gdata Entry(com.google.gdata.data.Entry)
+                // and modify accordingly
+
+            } 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);
+
+                // To-change
+                // For GDtata, feedEntry.getContent() will return a
+                // content(com.google.gdata.data.Content)
+                // mediator.mediate needs to be changed accordingly
+            }
+        } 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
+     */
+
+    // To-Change: org.apache.abdera.model.Entry --> com.google.gdata.data.Entry
+    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;
+
+            // To-change
+            // Get feed information from collection.item and create a new Gdata
+            // Entry
+            // For GDtata, the corresponding methods are quite different such as
+            // setTitle(), setContent(), setUpdated(), addLink()
+            //
+            // For example:
+            // entry.setTitle(new PlainTextConstruct("title_"));
+            // entry.setContent(new PlainTextConstruct("content_"));
+            // entry.setUpdated(DateTime.now());
+            // entry.addHtmlLink("http://www.google.com", "languageType",
+            // "title");
+            //
+            // I am going to use Gdata Entry(com.google.gdata.data.Entry) and
+            // modify accordingly
+
+        } 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;
+
+            // To-change
+            // Get feed information from XML data(item to XML first via
+            // mediator)
+            // and create a new Gdata Entry
+            // Modify GData Entry set methods accordingly
+
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Create a data item from an Gdata entry.
+     * 
+     * @param feedEntry
+     * @param itemClassType
+     * @param itemXMLType
+     * @param mediator
+     * @return
+     */
+    static Entry<Object, Object> entry(com.google.gdata.data.Entry feedEntry,
+                                       DataType<?> itemClassType,
+                                       DataType<?> itemXMLType,
+                                       Mediator mediator) {
+        if (feedEntry != null) {
+            if (itemClassType.getPhysical() == Item.class) {
+                String key = feedEntry.getId().toString();
+
+                Item item = new Item();
+                item.setTitle(feedEntry.getTitle().toString());
+                TextContent content = (TextContent)feedEntry.getContent();
+                item.setContents(content.getContent().getPlainText());
+
+                for (com.google.gdata.data.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());
+                    }
+                }
+
+                Date date = new Date(feedEntry.getUpdated().getValue());
+                item.setDate(date);
+                return new Entry<Object, Object>(key, item);
+
+            } else {
+                String key = null;
+                if (feedEntry.getId() != null) {
+                    key = feedEntry.getId();
+                }
+
+                // Create the item from XML
+                if (feedEntry.getContent() == null) {
+                    return null;
+                }
+
+                TextContent content = (TextContent)feedEntry.getContent();
+                String value = content.getContent().getPlainText();
+                Object data = mediator.mediate(value, itemXMLType, itemClassType, null);
+                return new Entry<Object, Object>(key, data);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Create an Gdata entry for a key and item from a collection.
+     * 
+     * @param entry
+     * @param itemClassType
+     * @param itemXMLType
+     * @param mediator
+     * @param factory
+     * @return
+     */
+    static com.google.gdata.data.Entry feedEntry(Entry<Object, Object> entry,
+                                                 DataType<?> itemClassType,
+                                                 DataType<?> itemXMLType,
+                                                 Mediator mediator) {
+
+        Object key = entry.getKey();
+        Object data = entry.getData();
+        if (data instanceof Item) {
+            Item item = (Item)data;
+
+            com.google.gdata.data.Entry feedEntry = new com.google.gdata.data.Entry();
+            if (key != null) {
+                feedEntry.setId(key.toString());
+            }
+            feedEntry.setTitle(new PlainTextConstruct(item.getTitle()));
+            feedEntry.setContent(new PlainTextConstruct(item.getContents()));
+
+            String href = item.getLink();
+            if (href == null && key != null) {
+                href = key.toString();
+            }
+
+            if (href != null) {
+                feedEntry.addHtmlLink(href, "", "");
+            }
+            String related = item.getRelated();
+            if (related != null) {
+                feedEntry.addHtmlLink(related, "", "related");
+            }
+            String alternate = item.getAlternate();
+            if (alternate != null) {
+                feedEntry.addHtmlLink(alternate, "", "alternate");
+            }
+
+            Date date = item.getDate();
+            if (date != null) {
+                DateTime datetime = new DateTime(date);
+                feedEntry.setUpdated(datetime);
+            }
+            return feedEntry;
+
+        } else if (data != null) {
+
+            com.google.gdata.data.Entry feedEntry = new com.google.gdata.data.Entry();
+            feedEntry.setId(key.toString());
+            feedEntry.setTitle(new PlainTextConstruct("item"));
+
+            // Convert the item to XML
+            String value = mediator.mediate(data, itemClassType, itemXMLType, null).toString();
+
+            // Might be wrong because the example uses XML datatype, I am using
+            // plainText here
+            feedEntry.setContent(new PlainTextConstruct(value));
+
+            feedEntry.addHtmlLink(key.toString(), "", "");
+            return feedEntry;
+
+        } else {
+            return null;
+        }
+    }
+
+}
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataReferenceBindingProvider.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataReferenceBindingProvider.java
new file mode 100644
index 0000000000..1748006469
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataReferenceBindingProvider.java
@@ -0,0 +1,214 @@
+/*
+ * 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.gdata.provider;
+
+import java.net.URI;
+
+import javax.xml.namespace.QName;
+
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.httpclient.Credentials;
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpConnectionManager;
+import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.auth.AuthScope;
+import org.apache.tuscany.sca.binding.gdata.GdataBinding;
+import org.apache.tuscany.sca.databinding.Mediator;
+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.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+
+/**
+ * Implementation of the Atom binding provider.
+ * 
+ * @version $Rev$ $Date$
+ */
+class GdataReferenceBindingProvider implements ReferenceBindingProvider {
+
+    private RuntimeComponentReference reference;
+    private GdataBinding binding;
+    private String authorizationHeader;
+    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
+     */
+    GdataReferenceBindingProvider(RuntimeComponent component,
+                                  RuntimeComponentReference reference,
+                                  GdataBinding binding,
+                                  Mediator mediator) {
+        this.reference = reference;
+        this.binding = binding;
+        this.mediator = mediator;
+
+        // Prepare authorization header
+        String authorization = "admin" + ":" + "admin";
+        authorizationHeader = "Basic " + new String(Base64.encodeBase64(authorization.getBytes()));
+
+        // Create an HTTP client
+        HttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
+        connectionManager.getParams().setDefaultMaxConnectionsPerHost(10);
+        connectionManager.getParams().setConnectionTimeout(60000);
+        httpClient = new HttpClient(connectionManager);
+    }
+
+    public Invoker createInvoker(Operation operation) {
+
+        String operationName = operation.getName();
+
+        // //System.out.println("GdataReferenceBindingProvider.createInvoker---operationName:"
+        // + operationName);
+
+        if (operationName.equals("get")) {
+
+            // Determine the collection item type
+            itemXMLType = new DataTypeImpl<Class<?>>(String.class.getName(), String.class, String.class);
+            Class<?> itemClass = operation.getOutputType().getPhysical();
+            DataType<XMLType> outputType = operation.getOutputType();
+            QName qname = outputType.getLogical().getElementName();
+            qname = new QName(qname.getNamespaceURI(), itemClass.getSimpleName());
+            itemClassType = new DataTypeImpl<XMLType>("java:complexType", itemClass, new XMLType(qname, null));
+
+            // To-change
+            // org.apache.abdera.model.Entry --> com.google.gdata.data.Entry;
+
+            if (itemClassType.getPhysical() == com.google.gdata.data.Entry.class) {
+                supportsFeedEntries = true;
+            }
+
+            // //System.out.println("GdataReferenceBindingProvider.createInvoker---operation=get");
+            return new GdataBindingInvoker.GetInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                      this);
+
+        } else if (operationName.equals("post")) {
+
+            // //System.out.println("GdataReferenceBindingProvider CreateInvoker
+            // --- post");
+            return new GdataBindingInvoker.PostInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                       this);
+
+        } else if (operationName.equals("put")) {
+
+            return new GdataBindingInvoker.PutInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                      this);
+        } else if (operationName.equals("delete")) {
+            return new GdataBindingInvoker.DeleteInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                         this);
+        } else if (operationName.equals("getFeed") || operationName.equals("getAll")) {
+
+            // //System.out.println("GdataReferenceBindingProvider
+            // CreateInvoker: getFeed or getAll");
+
+            return new GdataBindingInvoker.GetAllInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                         this);
+
+        } else if (operationName.equals("postMedia")) {
+            return new GdataBindingInvoker.PostMediaInvoker(operation, binding.getURI(), httpClient,
+                                                            authorizationHeader, this);
+        } else if (operationName.equals("putMedia")) {
+            return new GdataBindingInvoker.PutMediaInvoker(operation, binding.getURI(), httpClient,
+                                                           authorizationHeader, this);
+        } else if (operationName.equals("query")) {
+            return new GdataBindingInvoker.QueryInvoker(operation, binding.getURI(), httpClient, authorizationHeader,
+                                                        this);
+        }
+
+        return new GdataBindingInvoker(operation, binding.getURI(), httpClient, authorizationHeader, this);
+    }
+
+    public InterfaceContract getBindingInterfaceContract() {
+        return reference.getInterfaceContract();
+    }
+
+    public void start() {
+
+        // Configure the HTTP client credentials
+        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
+        if (true) {
+            return;
+        }
+    }
+
+    public void stop() {
+
+    }
+
+    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/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataServiceBindingProvider.java b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataServiceBindingProvider.java
new file mode 100644
index 0000000000..10faf74371
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/java/org/apache/tuscany/sca/binding/gdata/provider/GdataServiceBindingProvider.java
@@ -0,0 +1,90 @@
+/*
+ * 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.gdata.provider;
+
+import org.apache.tuscany.sca.binding.gdata.GdataBinding;
+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.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+
+/**
+ * Implementation of the Atom binding provider.
+ * 
+ * @version $Rev$ $Date$
+ */
+class GdataServiceBindingProvider implements ServiceBindingProvider {
+
+    private RuntimeComponentService service;
+    private GdataBinding binding;
+    private ServletHost servletHost;
+    private MessageFactory messageFactory;
+    private String servletMapping;
+    private Mediator mediator;
+
+    GdataServiceBindingProvider(RuntimeComponent component,
+                                RuntimeComponentService service,
+                                GdataBinding binding,
+                                ServletHost servletHost,
+                                MessageFactory messageFactory,
+                                Mediator mediator) {
+        this.service = service;
+        this.binding = binding;
+        this.servletHost = servletHost;
+        this.messageFactory = messageFactory;
+        this.mediator = mediator;
+    }
+
+    public InterfaceContract getBindingInterfaceContract() {
+        return service.getInterfaceContract();
+    }
+
+    public boolean supportsOneWayInvocation() {
+        return false;
+    }
+
+    public void start() {
+        RuntimeComponentService componentService = (RuntimeComponentService)service;
+        RuntimeWire wire = componentService.getRuntimeWire(binding);
+
+        GdataBindingListenerServlet servlet =
+            new GdataBindingListenerServlet(wire, messageFactory, mediator, binding.getTitle());
+
+        servletMapping = binding.getURI();
+        if (!servletMapping.endsWith("/")) {
+            servletMapping += "/";
+        }
+        if (!servletMapping.endsWith("*")) {
+            servletMapping += "*";
+        }
+        servletHost.addServletMapping(servletMapping, servlet);
+
+        // Save the actual binding URI in the binding
+        binding.setURI(servletHost.getURLMapping(binding.getURI()).toString());
+    }
+
+    public void stop() {
+        servletHost.removeServletMapping(servletMapping);
+    }
+}
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.BindingProviderFactory b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.BindingProviderFactory
new file mode 100644
index 0000000000..5e380eb4e0
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.BindingProviderFactory
@@ -0,0 +1,19 @@
+# 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. 
+
+# Implementation class for the binding extension
+org.apache.tuscany.sca.binding.gdata.provider.GdataBindingProviderFactory;model=org.apache.tuscany.sca.binding.gdata.GdataBinding
diff --git a/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/tuscany-binding-gdata.xsd b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/tuscany-binding-gdata.xsd
new file mode 100644
index 0000000000..5148e2ef2d
--- /dev/null
+++ b/java/sca/modules/binding-gdata-runtime-gsoc/src/main/resources/tuscany-binding-gdata.xsd
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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.    
+-->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" 
+    targetNamespace="http://echo" 
+    xmlns:sca="http://www.osoa.org/xmlns/sca/1.0"
+    xmlns:e="http://echo" 
+    elementFormDefault="qualified">
+
+    <import namespace="http://www.osoa.org/xmlns/sca/1.0"/>
+
+    <element name="binding.gdata" type="e:GdataBinding"/>
+    
+    <complexType name="GdataBinding">
+        <complexContent>
+            <extension base="sca:Binding">
+            </extension>
+        </complexContent>
+    </complexType>
+</schema>