git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /*
   2  * (C) Copyright 2006-2007 Nuxeo SAS (http://nuxeo.com/) and contributors.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the GNU Lesser General Public License
   6  * (LGPL) version 2.1 which accompanies this distribution, and is available at
   7  * http://www.gnu.org/licenses/lgpl.html
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * Contributors:
  15  *     Nuxeo - initial API and implementation
  16  *
  17  * $Id: JOOoConvertPluginImpl.java 18651 2007-05-13 20:28:53Z sfermigier $
  18  */
  19 package org.collectionspace.hello.services.nuxeo;
  20
  21 import java.io.IOException;
  22 import java.io.InputStream;
  23 import java.io.OutputStream;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27
  28 import org.restlet.Client;
  29 import org.restlet.data.ChallengeResponse;
  30 import org.restlet.data.ChallengeScheme;
  31 import org.restlet.data.Cookie;
  32 import org.restlet.data.Form;
  33 import org.restlet.data.MediaType;
  34 import org.restlet.data.Method;
  35 import org.restlet.data.Parameter;
  36 import org.restlet.data.Protocol;
  37 import org.restlet.data.Request;
  38 import org.restlet.resource.OutputRepresentation;
  39 import org.restlet.resource.Representation;
  40 import org.restlet.util.Series;
  41
  42 public class NuxeoRESTClient {
  43
  44     public static final int AUTH_TYPE_NONE = 0;
  45     public static final int AUTH_TYPE_BASIC = 1;
  46     public static final int AUTH_TYPE_SECRET = 2;
  47     protected String baseURL = "http://127.0.0.1:8080/nuxeo";
  48     protected String restPrefix = "restAPI";
  49     protected String davPrefix = "dav";
  50     protected List<Cookie> cookies;
  51     protected int authType = AUTH_TYPE_NONE;
  52     protected String userName;
  53     protected String password;
  54     protected String secretToken;
  55     protected Client restClient;
  56
  57     public NuxeoRESTClient(String baseURL) {
  58         this.baseURL = baseURL;
  59     }
  60
  61     public NuxeoRESTClient(String protocol, String serverIP, String serverPort) {
  62         this(protocol, serverIP, serverPort, "nuxeo");
  63     }
  64
  65     public NuxeoRESTClient(String protocol, String serverIP, String serverPort,
  66             String servletPath) {
  67         StringBuffer sb = new StringBuffer();
  68         sb.append(protocol);
  69         sb.append("://");
  70         sb.append(serverIP);
  71         if (serverPort != null && !serverIP.equals("80")) {
  72             sb.append(':');
  73             sb.append(serverPort);
  74         }
  75         sb.append(servletPath);
  76         sb.append('/');
  77         baseURL = sb.toString();
  78     }
  79
  80     public void setBasicAuthentication(String userName, String password) {
  81         authType = AUTH_TYPE_BASIC;
  82         this.userName = userName;
  83         this.password = password;
  84     }
  85
  86     public void setSharedSecretAuthentication(String userName,
  87             String secretToken) {
  88         authType = AUTH_TYPE_SECRET;
  89         this.userName = userName;
  90         this.secretToken = secretToken;
  91     }
  92
  93     public void setCookies(List<Cookie> cookies) {
  94         this.cookies = cookies;
  95     }
  96
  97     public Representation post(List<String> pathParams,
  98             Map<String, String> queryParams, InputStream istream) {
  99         String path = "";
 100         StringBuffer pathBuffer = new StringBuffer();
 101
 102         if (pathParams != null) {
 103             for (String p : pathParams) {
 104                 pathBuffer.append(p);
 105                 pathBuffer.append('/');
 106             }
 107             path = pathBuffer.toString();
 108         }
 109
 110         return post(path, queryParams, istream);
 111     }
 112
 113     public Representation post(String subPath,
 114             Map<String, String> queryParams, InputStream istream) {
 115         StringBuffer urlBuffer = new StringBuffer();
 116
 117         if (subPath.startsWith("/")) {
 118             subPath = subPath.substring(1);
 119         }
 120         if (subPath.endsWith("/")) {
 121             subPath = subPath.substring(0, subPath.length() - 1);
 122         }
 123
 124         urlBuffer.append(baseURL);
 125         urlBuffer.append('/');
 126         urlBuffer.append(restPrefix);
 127         urlBuffer.append('/');
 128         urlBuffer.append(subPath);
 129
 130         if (queryParams != null) {
 131             urlBuffer.append('?');
 132             for (String qpName : queryParams.keySet()) {
 133                 urlBuffer.append(qpName);
 134                 urlBuffer.append('=');
 135                 urlBuffer.append(queryParams.get(qpName).replaceAll(" ", "%20"));
 136                 urlBuffer.append('&');
 137             }
 138         }
 139
 140         String completeURL = urlBuffer.toString();
 141
 142         Request request = new Request(Method.POST, completeURL);
 143
 144         setupAuth(request);
 145         setupCookies(request);
 146         final InputStream in = istream;
 147         request.setEntity(new OutputRepresentation(
 148                 MediaType.MULTIPART_FORM_DATA) {
 149
 150             @Override
 151             public void write(OutputStream outputStream) throws IOException {
 152                 byte[] buffer = new byte[1024 * 64];
 153                 int read;
 154                 while ((read = in.read(buffer)) != -1) {
 155                     outputStream.write(buffer, 0, read);
 156                 }
 157
 158             }
 159         });
 160
 161         return getRestClient().handle(request).getEntity();
 162     }
 163
 164     public Representation get(List<String> pathParams,
 165             Map<String, String> queryParams) {
 166         String path = "";
 167         StringBuffer pathBuffer = new StringBuffer();
 168
 169         if (pathParams != null) {
 170             for (String p : pathParams) {
 171                 pathBuffer.append(p);
 172                 pathBuffer.append('/');
 173             }
 174             path = pathBuffer.toString();
 175         }
 176
 177         return get(path, queryParams);
 178     }
 179
 180     public Representation get(String subPath,
 181             Map<String, String> queryParams) {
 182         StringBuffer urlBuffer = new StringBuffer();
 183
 184         if (subPath.startsWith("/")) {
 185             subPath = subPath.substring(1);
 186         }
 187         if (subPath.endsWith("/")) {
 188             subPath = subPath.substring(0, subPath.length() - 1);
 189         }
 190
 191         urlBuffer.append(baseURL);
 192         urlBuffer.append('/');
 193         urlBuffer.append(restPrefix);
 194         urlBuffer.append('/');
 195         urlBuffer.append(subPath);
 196
 197         if (queryParams != null) {
 198             urlBuffer.append('?');
 199             for (String qpName : queryParams.keySet()) {
 200                 urlBuffer.append(qpName);
 201                 urlBuffer.append('=');
 202                 urlBuffer.append(queryParams.get(qpName).replaceAll(" ", "%20"));
 203                 urlBuffer.append('&');
 204             }
 205         }
 206
 207         String completeURL = urlBuffer.toString();
 208         System.out.println("\nNuxeoRESTClient: calling " + completeURL);
 209         Request request = new Request(Method.GET, completeURL);
 210         setupAuth(request);
 211         setupCookies(request);
 212
 213         return getRestClient().handle(request).getEntity();
 214     }
 215
 216     protected void setupAuth(Request request) {
 217
 218         if (authType == AUTH_TYPE_BASIC) {
 219             ChallengeScheme scheme = ChallengeScheme.HTTP_BASIC;
 220             ChallengeResponse authentication = new ChallengeResponse(scheme,
 221                     userName, password);
 222             request.setChallengeResponse(authentication);
 223
 224         } else if (authType == AUTH_TYPE_SECRET) {
 225             Series<Parameter> additionnalHeaders = new Form();
 226
 227             Map<String, String> securityHeaders = PortalSSOAuthenticationProvider.getHeaders(
 228                     secretToken, userName);
 229
 230             for (String hn : securityHeaders.keySet()) {
 231                 additionnalHeaders.add(hn, securityHeaders.get(hn));
 232             }
 233
 234             request.getAttributes().put("org.restlet.http.headers",
 235                     additionnalHeaders);
 236         }
 237     }
 238
 239     protected void setupCookies(Request request) {
 240         if (cookies != null) {
 241             request.getCookies().clear();
 242             for (Cookie cookie : cookies) {
 243                 request.getCookies().add(cookie);
 244             }
 245         }
 246
 247     }
 248
 249     protected Client getRestClient() {
 250         if (restClient == null) {
 251             if (baseURL.startsWith("https")) {
 252                 restClient = new Client(Protocol.HTTPS);
 253             } else {
 254                 restClient = new Client(Protocol.HTTP);
 255             }
 256         }
 257
 258         return restClient;
 259     }
 260
 261     public int getAuthType() {
 262         return authType;
 263     }
 264
 265     public void setAuthType(int authType) {
 266         this.authType = authType;
 267     }
 268
 269     public String getDavPrefix() {
 270         return davPrefix;
 271     }
 272
 273     public void setDavPrefix(String davPrefix) {
 274         this.davPrefix = davPrefix;
 275     }
 276
 277     public String getPassword() {
 278         return password;
 279     }
 280
 281     public void setPassword(String password) {
 282         this.password = password;
 283     }
 284
 285     public String getRestPrefix() {
 286         return restPrefix;
 287     }
 288
 289     public void setRestPrefix(String restPrefix) {
 290         this.restPrefix = restPrefix;
 291     }
 292
 293     public String getSecretToken() {
 294         return secretToken;
 295     }
 296
 297     public void setSecretToken(String secretToken) {
 298         this.secretToken = secretToken;
 299     }
 300
 301     public String getUserName() {
 302         return userName;
 303     }
 304
 305     public void setUserName(String userName) {
 306         this.userName = userName;
 307     }
 308 }