gerrit.onap Code Review - so/libs.git/blob

   1 package com.woorea.openstack.connector;
   2
   3 import java.util.List;
   4 import java.util.Map;
   5 import java.util.Map.Entry;
   6
   7 import javax.ws.rs.core.UriBuilder;
   8 import javax.ws.rs.ext.ContextResolver;
   9
  10 import org.apache.commons.httpclient.HttpStatus;
  11 import org.codehaus.jackson.jaxrs.JacksonJsonProvider;
  12 import org.codehaus.jackson.map.DeserializationConfig;
  13 import org.codehaus.jackson.map.ObjectMapper;
  14 import org.codehaus.jackson.map.SerializationConfig;
  15 import org.codehaus.jackson.map.annotate.JsonRootName;
  16 import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
  17 import org.jboss.resteasy.client.ClientRequest;
  18 import org.jboss.resteasy.client.ClientResponse;
  19 import org.jboss.resteasy.plugins.providers.InputStreamProvider;
  20 import org.jboss.resteasy.spi.ResteasyProviderFactory;
  21
  22 import com.woorea.openstack.base.client.OpenStackClientConnector;
  23 import com.woorea.openstack.base.client.OpenStackRequest;
  24 import com.woorea.openstack.base.client.OpenStackResponse;
  25 import com.woorea.openstack.base.client.OpenStackResponseException;
  26
  27 public class RESTEasyConnector implements OpenStackClientConnector {
  28
  29         public static ObjectMapper DEFAULT_MAPPER;
  30
  31         public static ObjectMapper WRAPPED_MAPPER;
  32
  33         static class OpenStackProviderFactory extends ResteasyProviderFactory {
  34
  35                 private JacksonJsonProvider jsonProvider;
  36                 private InputStreamProvider streamProvider;
  37
  38                 public OpenStackProviderFactory() {
  39                         super();
  40
  41                         addContextResolver(new ContextResolver<ObjectMapper>() {
  42                                 public ObjectMapper getContext(Class<?> type) {
  43                                         return type.getAnnotation(JsonRootName.class) == null ? DEFAULT_MAPPER : WRAPPED_MAPPER;
  44                                 }
  45                         });
  46
  47                         jsonProvider = new JacksonJsonProvider();
  48                         addMessageBodyReader(jsonProvider);
  49                         addMessageBodyWriter(jsonProvider);
  50
  51                         streamProvider = new InputStreamProvider();
  52                         addMessageBodyReader(streamProvider);
  53                         addMessageBodyWriter(streamProvider);
  54                 }
  55
  56         }
  57
  58         private static OpenStackProviderFactory providerFactory;
  59
  60         static {
  61                 DEFAULT_MAPPER = new ObjectMapper();
  62
  63                 DEFAULT_MAPPER.setSerializationInclusion(Inclusion.NON_NULL);
  64                 DEFAULT_MAPPER.enable(SerializationConfig.Feature.INDENT_OUTPUT);
  65                 DEFAULT_MAPPER.enable(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
  66                 DEFAULT_MAPPER.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
  67                 DEFAULT_MAPPER.enable(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
  68
  69                 WRAPPED_MAPPER = new ObjectMapper();
  70
  71                 WRAPPED_MAPPER.setSerializationInclusion(Inclusion.NON_NULL);
  72                 WRAPPED_MAPPER.enable(SerializationConfig.Feature.INDENT_OUTPUT);
  73                 WRAPPED_MAPPER.enable(SerializationConfig.Feature.WRAP_ROOT_VALUE);
  74                 WRAPPED_MAPPER.enable(DeserializationConfig.Feature.UNWRAP_ROOT_VALUE);
  75                 WRAPPED_MAPPER.enable(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
  76                 WRAPPED_MAPPER.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
  77                 WRAPPED_MAPPER.enable(DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
  78
  79                 providerFactory = new OpenStackProviderFactory();
  80         }
  81
  82         public <T> OpenStackResponse request(OpenStackRequest<T> request) {
  83                 ClientRequest client = new ClientRequest(UriBuilder.fromUri(request.endpoint() + "/" + request.path()),
  84                                 ClientRequest.getDefaultExecutor(), providerFactory);
  85
  86                 for(Map.Entry<String, List<Object> > entry : request.queryParams().entrySet()) {
  87                         for (Object o : entry.getValue()) {
  88                                 client = client.queryParameter(entry.getKey(), String.valueOf(o));
  89                         }
  90                 }
  91
  92                 for (Entry<String, List<Object>> h : request.headers().entrySet()) {
  93                         StringBuilder sb = new StringBuilder();
  94                         for (Object v : h.getValue()) {
  95                                 sb.append(String.valueOf(v));
  96                         }
  97                         client.header(h.getKey(), sb);
  98                 }
  99
 100                 if (request.entity() != null) {
 101                         client.body(request.entity().getContentType(), request.entity().getEntity());
 102                 }
 103
 104                 ClientResponse<T> response;
 105
 106                 try {
 107                         response = client.httpMethod(request.method().name(), request.returnType());
 108                 } catch (Exception e) {
 109                         throw new RuntimeException("Unexpected client exception", e);
 110                 }
 111
 112                 if (response.getStatus() == HttpStatus.SC_OK
 113                                 || response.getStatus() == HttpStatus.SC_CREATED
 114                                 || response.getStatus() == HttpStatus.SC_NO_CONTENT
 115                                 || response.getStatus() == HttpStatus.SC_ACCEPTED) {
 116                         return new RESTEasyResponse(client, response);
 117                 }
 118
 119                 response.releaseConnection();
 120
 121                 throw new OpenStackResponseException(response.getResponseStatus()
 122                                 .getReasonPhrase(), response.getStatus());
 123         }
 124
 125 }