View Javadoc

1   /*
2    * $Id: AbderaServiceComponent.java 22439 2011-07-18 19:06:39Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  package org.mule.module.atom;
11  
12  import org.mule.DefaultMuleMessage;
13  import org.mule.api.MuleContext;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleEventContext;
16  import org.mule.api.MuleException;
17  import org.mule.api.MuleMessage;
18  import org.mule.api.lifecycle.Callable;
19  import org.mule.api.transport.OutputHandler;
20  import org.mule.component.DefaultJavaComponent;
21  import org.mule.module.atom.server.MuleRequestContext;
22  import org.mule.object.SingletonObjectFactory;
23  import org.mule.transport.http.HttpConnector;
24  import org.mule.transport.http.HttpConstants;
25  import org.mule.util.StringUtils;
26  
27  import java.io.IOException;
28  import java.io.OutputStream;
29  import java.net.URI;
30  import java.util.Date;
31  import java.util.HashMap;
32  
33  import javax.activation.MimeType;
34  
35  import org.apache.abdera.Abdera;
36  import org.apache.abdera.i18n.iri.IRI;
37  import org.apache.abdera.protocol.server.FilterChain;
38  import org.apache.abdera.protocol.server.Provider;
39  import org.apache.abdera.protocol.server.RequestContext.Scope;
40  import org.apache.abdera.protocol.server.ResponseContext;
41  import org.apache.commons.logging.Log;
42  import org.apache.commons.logging.LogFactory;
43  
44  /**
45   * This component receives requests from Mule and passes them off to Abdera.
46   */
47  public class AbderaServiceComponent extends DefaultJavaComponent
48  {
49      public static final String EVENT_CONTEXT = "_muleEventContext";
50  
51      private Provider provider;
52  
53      public AbderaServiceComponent()
54      {
55          super();
56  
57          setObjectFactory(new SingletonObjectFactory(new AbderaCallable(this)));
58      }
59  
60  
61      public static final class AbderaCallable implements Callable
62      {
63          protected static transient final Log logger = LogFactory.getLog(AbderaServiceComponent.class);
64  
65          private final AbderaServiceComponent abderaServiceComponent;
66  
67          public AbderaCallable(AbderaServiceComponent abderaServiceComponent)
68          {
69              this.abderaServiceComponent = abderaServiceComponent;
70          }
71  
72          public Object onCall(MuleEventContext event) throws MuleException
73          {
74              if (logger.isDebugEnabled())
75              {
76                  logger.debug(event.getMessageAsString());
77              }
78  
79              MuleMessage msg = event.getMessage();
80              IRI baseIri = initBaseUri(event.getEndpointURI());
81              String contextPath = msg.getInboundProperty(HttpConnector.HTTP_REQUEST_PROPERTY, StringUtils.EMPTY);
82  
83              Provider provider = abderaServiceComponent.getProvider();
84              MuleRequestContext reqcontext = new MuleRequestContext(provider,
85                                                                     event,
86                                                                     msg,
87                                                                     contextPath,
88                                                                     baseIri);
89              reqcontext.setAttribute(Scope.REQUEST, EVENT_CONTEXT, event);
90  
91              FilterChain chain = new FilterChain(provider, reqcontext);
92  
93              try
94              {
95                  return output(msg, chain.next(reqcontext), event.getMuleContext());
96              }
97              catch (IOException e)
98              {
99                  throw new RuntimeException(e);
100             }
101         }
102 
103         private IRI initBaseUri(URI endpointURI)
104         {
105             String iri = endpointURI.toString();
106             if (!iri.endsWith("/"))
107             {
108                 iri = iri + "/";
109             }
110 
111             return new IRI(iri);
112         }
113 
114         private MuleMessage output(final MuleMessage request,
115                                    final ResponseContext context, final MuleContext muleContext) throws IOException
116         {
117             OutputHandler payload = new OutputHandler()
118             {
119 
120                 public void write(MuleEvent event, OutputStream out) throws IOException
121                 {
122                     if (context.hasEntity())
123                     {
124                         context.writeTo(out);
125                         out.flush();
126                     }
127                 }
128 
129             };
130             DefaultMuleMessage response = new DefaultMuleMessage(payload, muleContext);
131 
132             response.setOutboundProperty(HttpConnector.HTTP_STATUS_PROPERTY, context.getStatus());
133             long cl = context.getContentLength();
134             String cc = context.getCacheControl();
135             if (cl > -1)
136             {
137                 response.setOutboundProperty("Content-Length", Long.toString(cl));
138             }
139             if (cc != null && cc.length() > 0)
140             {
141                 response.setOutboundProperty("Cache-Control", cc);
142             }
143 
144             MimeType ct = context.getContentType();
145             if (ct != null)
146             {
147                 response.setOutboundProperty(HttpConstants.HEADER_CONTENT_TYPE, ct.toString());
148             }
149 
150             String[] names = context.getHeaderNames();
151             for (String name : names)
152             {
153                 Object[] headers = context.getHeaders(name);
154                 for (Object value : headers)
155                 {
156                     if (value instanceof Date)
157                     {
158                         throw new RuntimeException();
159                     }
160 //                        response.setDateHeader(name, ((Date)value).getTime());
161                     else
162                     {
163                         response.setOutboundProperty(name, value.toString());
164                     }
165                 }
166             }
167 
168             return response;
169         }
170 
171     }
172 
173     public Provider getProvider()
174     {
175         return provider;
176     }
177 
178     public void setProvider(Provider provider)
179     {
180         this.provider = provider;
181         provider.init(Abdera.getInstance(), new HashMap<String, String>());
182     }
183 }