Coverage Report

Coverage Report - org.kuali.rice.ksb.api.bus.support.AbstractServiceDefinition

Classes in this File

Line Coverage

Branch Coverage

Complexity

AbstractServiceDefinition

57%

66/114

29%

14/48

1.744

 /**
  * Copyright 2005-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
  *
  * 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.kuali.rice.ksb.api.bus.support;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
 import org.apache.commons.lang.builder.ReflectionToStringBuilder;
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.api.CoreConstants;
 import org.kuali.rice.core.api.config.ConfigurationException;
 import org.kuali.rice.core.api.config.CoreConfigHelper;
 import org.kuali.rice.core.api.config.property.ConfigContext;
 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
 import org.kuali.rice.core.api.security.credentials.CredentialsType;
 import org.kuali.rice.core.api.util.ClassLoaderUtils;
 import org.kuali.rice.ksb.api.bus.Endpoint;
 import org.kuali.rice.ksb.api.bus.ServiceConfiguration;
 import org.kuali.rice.ksb.api.bus.ServiceDefinition;
 
 import javax.xml.namespace.QName;
 import java.net.URL;
 
 
 /**
  * The definition of a service on the service bus.
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public abstract class AbstractServiceDefinition implements ServiceDefinition {
 
         private static final Logger LOG = Logger.getLogger(AbstractServiceDefinition.class);
                 
         // used internally to construct the service name
         private String localServiceName;
         private String serviceNameSpaceURI;
         
         private Object service;
         private QName serviceName;
         private boolean queue;
         private Integer priority;
         private Integer retryAttempts;
         private Long millisToLive;
         private String messageExceptionHandler;
         private String servicePath;
         private URL endpointUrl;
         private Boolean busSecurity;
         private CredentialsType credentialsType;
         private String serviceVersion;
         private String applicationId;
     private String instanceId;
 
         // if the service is exported from a plugin, we need to ensure it's invoked within the proper classloading context!
         private ClassLoader serviceClassLoader;
     private String cacheManager;
                         
         protected AbstractServiceDefinition() {
                 this.busSecurity = Boolean.TRUE;
                 this.queue = true;
                 this.serviceClassLoader = ClassLoaderUtils.getDefaultClassLoader();
         }
 
         public Object getService() {
                 return this.service;
         }
         public void setService(Object service) {
                 this.service = service;
         }
         
         public String getLocalServiceName() {
                 return this.localServiceName;
         }
         
         public void setLocalServiceName(String serviceName) {
                 this.localServiceName = serviceName;
         }
         
         public String getMessageExceptionHandler() {
                 return this.messageExceptionHandler;
         }
         
         public void setMessageExceptionHandler(String messageExceptionHandler) {
                 this.messageExceptionHandler = messageExceptionHandler;
         }
         
         public Integer getPriority() {
                 return this.priority;
         }
         
         public void setPriority(Integer priority) {
                 this.priority = priority;
         }
         
         public boolean isQueue() {
                 return this.queue;
         }
         
         public void setQueue(boolean queue) {
                 this.queue = queue;
         }
         
         public Integer getRetryAttempts() {
                 return this.retryAttempts;
         }
         
         public void setRetryAttempts(Integer retryAttempts) {
                 this.retryAttempts = retryAttempts;
         }
 
         public QName getServiceName() {
                 if (this.serviceName == null) {
                         if (this.serviceNameSpaceURI == null) {
                             return new QName(this.applicationId, this.localServiceName);        
                         } else {
                             return new QName(this.serviceNameSpaceURI, this.localServiceName);
                         }
                         
                 }
                 return this.serviceName;
         }
         public void setServiceName(QName serviceName) {
                 this.serviceName = serviceName;
         }
         
         @Override
         public URL getEndpointUrl() {
                 return this.endpointUrl;
         }
         public void setEndpointUrl(URL endpointUrl) {
                 this.endpointUrl = endpointUrl;
         }
         
         public void setCredentialsType(CredentialsType credentialsType) {
             this.credentialsType = credentialsType;
         }
         
         public CredentialsType getCredentialsType() {
             return this.credentialsType;
         }
         
         public String getServiceVersion() {
                 return serviceVersion;
         }
 
         public void setServiceVersion(String serviceVersion) {
                 this.serviceVersion = serviceVersion;
         }
 
         public String getApplicationId() {
                 return applicationId;
         }
         
         public void setApplicationId(String applicationId) {
                 this.applicationId = applicationId;
         }
 
     @Override
     public String getInstanceId() {
         return instanceId;
     }
 
     public void setInstanceId(String instanceId) {
         this.instanceId = instanceId;
     }
 
     @Override
         public ClassLoader getServiceClassLoader() {
                 return this.serviceClassLoader;
         }
         
         public void setServiceClassLoader(ClassLoader serviceClassLoader) {
                 this.serviceClassLoader = serviceClassLoader;
         }
 
     @Override
     public String getCacheManager() {
         return cacheManager;
     }
 
     public void setCacheManager(String cacheManager) {
         this.cacheManager = cacheManager;
     }
         
         @Override
         public void validate() {
                 
                 if (this.serviceName == null && this.localServiceName == null) {
                         throw new ConfigurationException("Must give a serviceName or localServiceName");
                 }
 
                 if (this.applicationId == null) {
                         String applicationId = CoreConfigHelper.getApplicationId();
                         if (applicationId == null) {
                                 throw new ConfigurationException("Must have an applicationId");
                         }        
                         this.applicationId = applicationId;
                 }
 
         if (this.instanceId == null) {
                         String instanceId = CoreConfigHelper.getInstanceId();
                         if (instanceId == null) {
                                 throw new ConfigurationException("Must have an instanceId");
                         }
                         this.instanceId = instanceId;
                 }
                 
                 if (this.serviceName != null && this.localServiceName == null) {
                         this.localServiceName = this.getServiceName().getLocalPart();
                 }
                         
                 if (this.servicePath != null){
                         if (this.servicePath.endsWith("/")){
                                 this.servicePath = StringUtils.chop(servicePath);
                         }
                         if (!this.servicePath.startsWith("/")){
                                 this.servicePath = "/" + this.servicePath;
                         }
                 } else {
             // default the serivce path to namespace
                         this.servicePath = "/";
                 }
                 
                 // default to 'unspecified' service version
                 if (StringUtils.isBlank(serviceVersion)) {
                         setServiceVersion(CoreConstants.Versions.UNSPECIFIED);
                 }
 
                 LOG.debug("Validating service " + this.serviceName);
                 
                 
                 if (this.endpointUrl == null) {
                         String endPointURL = ConfigContext.getCurrentContextConfig().getEndPointUrl();
                         if (endPointURL == null) {
                                 throw new ConfigurationException("Must provide a serviceEndPoint or serviceServletURL");
                         }
                         if (! endPointURL.endsWith("/")) {
                                 endPointURL += servicePath;
                         } else {
                                 endPointURL = StringUtils.chop(endPointURL) + servicePath;
                         }
                         try {
                                 if (servicePath.equals("/")){
                                         this.endpointUrl = new URL(endPointURL + this.getServiceName().getLocalPart());
                                 } else {
                                         this.endpointUrl = new URL(endPointURL + "/" + this.getServiceName().getLocalPart());
                                 }
             } catch (Exception e) {
                                 throw new ConfigurationException("Service Endpoint URL creation failed.", e);
                         }
                         
                 }
                                 
                 if (this.priority == null) {
                         setPriority(5);
                 }
                 
                 if (this.retryAttempts == null) {
                         setRetryAttempts(0);
                 }
                 
                 if (this.millisToLive == null) {
                         setMillisToLive(new Long(-1));
                 }
 
         if (StringUtils.isBlank(cacheManager)) {
             LOG.warn("The cache manager was blank for " + (serviceName != null ? serviceName : localServiceName) + ". This service will not have client-side caching.");
         } else if (GlobalResourceLoader.getService(cacheManager) == null){
             //FIXME: it seems that the spring bean isn't available here or something....
             //LOG.warn("The cache manager " + cacheManager + " was not found for " + (serviceName != null ? serviceName : localServiceName) + ". This service will not have client-side caching.");
         }
 
         }
         
         @Override
         public Endpoint establishEndpoint() {
                 return BasicEndpoint.newEndpoint(configure(), getService());
         }
         
         protected abstract ServiceConfiguration configure();
         
         public String getServiceNameSpaceURI() {
                 return this.serviceNameSpaceURI;
         }
         public void setServiceNameSpaceURI(String serviceNameSpaceURI) {
                 this.serviceNameSpaceURI = serviceNameSpaceURI;
         }
         public Long getMillisToLive() {
                 return this.millisToLive;
         }
         public void setMillisToLive(Long millisToLive) {
                 this.millisToLive = millisToLive;
         }
         public Boolean getBusSecurity() {
                 return this.busSecurity;
         }
         public void setBusSecurity(Boolean busSecurity) {
                 this.busSecurity = busSecurity;
         }
         
         /**
          * @return the servicePath
          */
         public String getServicePath() {
                 return this.servicePath;
         }
 
         /**
          * @param servicePath the servicePath to set
          */
         public void setServicePath(String servicePath) {
                 this.servicePath = servicePath;
         }
         
         public String toString() {
             return ReflectionToStringBuilder.toString(this);
         }
         
         @Override
     public boolean equals(Object object) {
                 return EqualsBuilder.reflectionEquals(object, this);
     }
 
         @Override
     public int hashCode() {
         return HashCodeBuilder.reflectionHashCode(this);
     }
 
         
 }

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.ksb.api.bus.support;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.apache.commons.lang.builder.EqualsBuilder;
20		import org.apache.commons.lang.builder.HashCodeBuilder;
21		import org.apache.commons.lang.builder.ReflectionToStringBuilder;
22		import org.apache.log4j.Logger;
23		import org.kuali.rice.core.api.CoreConstants;
24		import org.kuali.rice.core.api.config.ConfigurationException;
25		import org.kuali.rice.core.api.config.CoreConfigHelper;
26		import org.kuali.rice.core.api.config.property.ConfigContext;
27		import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
28		import org.kuali.rice.core.api.security.credentials.CredentialsType;
29		import org.kuali.rice.core.api.util.ClassLoaderUtils;
30		import org.kuali.rice.ksb.api.bus.Endpoint;
31		import org.kuali.rice.ksb.api.bus.ServiceConfiguration;
32		import org.kuali.rice.ksb.api.bus.ServiceDefinition;
33
34		import javax.xml.namespace.QName;
35		import java.net.URL;
36
37
38		/**
39		* The definition of a service on the service bus.
40		*
41		* @author Kuali Rice Team (rice.collab@kuali.org)
42		*/
43		public abstract class AbstractServiceDefinition implements ServiceDefinition {
44
45	1	private static final Logger LOG = Logger.getLogger(AbstractServiceDefinition.class);
46
47		// used internally to construct the service name
48		private String localServiceName;
49		private String serviceNameSpaceURI;
50
51		private Object service;
52		private QName serviceName;
53		private boolean queue;
54		private Integer priority;
55		private Integer retryAttempts;
56		private Long millisToLive;
57		private String messageExceptionHandler;
58		private String servicePath;
59		private URL endpointUrl;
60		private Boolean busSecurity;
61		private CredentialsType credentialsType;
62		private String serviceVersion;
63		private String applicationId;
64		private String instanceId;
65
66		// if the service is exported from a plugin, we need to ensure it's invoked within the proper classloading context!
67		private ClassLoader serviceClassLoader;
68		private String cacheManager;
69
70	8	protected AbstractServiceDefinition() {
71	8	this.busSecurity = Boolean.TRUE;
72	8	this.queue = true;
73	8	this.serviceClassLoader = ClassLoaderUtils.getDefaultClassLoader();
74	8	}
75
76		public Object getService() {
77	3	return this.service;
78		}
79		public void setService(Object service) {
80	1	this.service = service;
81	1	}
82
83		public String getLocalServiceName() {
84	0	return this.localServiceName;
85		}
86
87		public void setLocalServiceName(String serviceName) {
88	0	this.localServiceName = serviceName;
89	0	}
90
91		public String getMessageExceptionHandler() {
92	8	return this.messageExceptionHandler;
93		}
94
95		public void setMessageExceptionHandler(String messageExceptionHandler) {
96	1	this.messageExceptionHandler = messageExceptionHandler;
97	1	}
98
99		public Integer getPriority() {
100	8	return this.priority;
101		}
102
103		public void setPriority(Integer priority) {
104	2	this.priority = priority;
105	2	}
106
107		public boolean isQueue() {
108	8	return this.queue;
109		}
110
111		public void setQueue(boolean queue) {
112	1	this.queue = queue;
113	1	}
114
115		public Integer getRetryAttempts() {
116	8	return this.retryAttempts;
117		}
118
119		public void setRetryAttempts(Integer retryAttempts) {
120	2	this.retryAttempts = retryAttempts;
121	2	}
122
123		public QName getServiceName() {
124	9	if (this.serviceName == null) {
125	0	if (this.serviceNameSpaceURI == null) {
126	0	return new QName(this.applicationId, this.localServiceName);
127		} else {
128	0	return new QName(this.serviceNameSpaceURI, this.localServiceName);
129		}
130
131		}
132	9	return this.serviceName;
133		}
134		public void setServiceName(QName serviceName) {
135	8	this.serviceName = serviceName;
136	8	}
137
138		@Override
139		public URL getEndpointUrl() {
140	8	return this.endpointUrl;
141		}
142		public void setEndpointUrl(URL endpointUrl) {
143	8	this.endpointUrl = endpointUrl;
144	8	}
145
146		public void setCredentialsType(CredentialsType credentialsType) {
147	1	this.credentialsType = credentialsType;
148	1	}
149
150		public CredentialsType getCredentialsType() {
151	8	return this.credentialsType;
152		}
153
154		public String getServiceVersion() {
155	8	return serviceVersion;
156		}
157
158		public void setServiceVersion(String serviceVersion) {
159	8	this.serviceVersion = serviceVersion;
160	8	}
161
162		public String getApplicationId() {
163	8	return applicationId;
164		}
165
166		public void setApplicationId(String applicationId) {
167	8	this.applicationId = applicationId;
168	8	}
169
170		@Override
171		public String getInstanceId() {
172	8	return instanceId;
173		}
174
175		public void setInstanceId(String instanceId) {
176	3	this.instanceId = instanceId;
177	3	}
178
179		@Override
180		public ClassLoader getServiceClassLoader() {
181	0	return this.serviceClassLoader;
182		}
183
184		public void setServiceClassLoader(ClassLoader serviceClassLoader) {
185	0	this.serviceClassLoader = serviceClassLoader;
186	0	}
187
188		@Override
189		public String getCacheManager() {
190	8	return cacheManager;
191		}
192
193		public void setCacheManager(String cacheManager) {
194	0	this.cacheManager = cacheManager;
195	0	}
196
197		@Override
198		public void validate() {
199
200	1	if (this.serviceName == null && this.localServiceName == null) {
201	0	throw new ConfigurationException("Must give a serviceName or localServiceName");
202		}
203
204	1	if (this.applicationId == null) {
205	0	String applicationId = CoreConfigHelper.getApplicationId();
206	0	if (applicationId == null) {
207	0	throw new ConfigurationException("Must have an applicationId");
208		}
209	0	this.applicationId = applicationId;
210		}
211
212	1	if (this.instanceId == null) {
213	0	String instanceId = CoreConfigHelper.getInstanceId();
214	0	if (instanceId == null) {
215	0	throw new ConfigurationException("Must have an instanceId");
216		}
217	0	this.instanceId = instanceId;
218		}
219
220	1	if (this.serviceName != null && this.localServiceName == null) {
221	1	this.localServiceName = this.getServiceName().getLocalPart();
222		}
223
224	1	if (this.servicePath != null){
225	0	if (this.servicePath.endsWith("/")){
226	0	this.servicePath = StringUtils.chop(servicePath);
227		}
228	0	if (!this.servicePath.startsWith("/")){
229	0	this.servicePath = "/" + this.servicePath;
230		}
231		} else {
232		// default the serivce path to namespace
233	1	this.servicePath = "/";
234		}
235
236		// default to 'unspecified' service version
237	1	if (StringUtils.isBlank(serviceVersion)) {
238	0	setServiceVersion(CoreConstants.Versions.UNSPECIFIED);
239		}
240
241	1	LOG.debug("Validating service " + this.serviceName);
242
243
244	1	if (this.endpointUrl == null) {
245	0	String endPointURL = ConfigContext.getCurrentContextConfig().getEndPointUrl();
246	0	if (endPointURL == null) {
247	0	throw new ConfigurationException("Must provide a serviceEndPoint or serviceServletURL");
248		}
249	0	if (! endPointURL.endsWith("/")) {
250	0	endPointURL += servicePath;
251		} else {
252	0	endPointURL = StringUtils.chop(endPointURL) + servicePath;
253		}
254		try {
255	0	if (servicePath.equals("/")){
256	0	this.endpointUrl = new URL(endPointURL + this.getServiceName().getLocalPart());
257		} else {
258	0	this.endpointUrl = new URL(endPointURL + "/" + this.getServiceName().getLocalPart());
259		}
260	0	} catch (Exception e) {
261	0	throw new ConfigurationException("Service Endpoint URL creation failed.", e);
262	0	}
263
264		}
265
266	1	if (this.priority == null) {
267	1	setPriority(5);
268		}
269
270	1	if (this.retryAttempts == null) {
271	1	setRetryAttempts(0);
272		}
273
274	1	if (this.millisToLive == null) {
275	1	setMillisToLive(new Long(-1));
276		}
277
278	1	if (StringUtils.isBlank(cacheManager)) {
279	1	LOG.warn("The cache manager was blank for " + (serviceName != null ? serviceName : localServiceName) + ". This service will not have client-side caching.");
280	0	} else if (GlobalResourceLoader.getService(cacheManager) == null){
281		//FIXME: it seems that the spring bean isn't available here or something....
282		//LOG.warn("The cache manager " + cacheManager + " was not found for " + (serviceName != null ? serviceName : localServiceName) + ". This service will not have client-side caching.");
283		}
284
285	1	}
286
287		@Override
288		public Endpoint establishEndpoint() {
289	0	return BasicEndpoint.newEndpoint(configure(), getService());
290		}
291
292		protected abstract ServiceConfiguration configure();
293
294		public String getServiceNameSpaceURI() {
295	0	return this.serviceNameSpaceURI;
296		}
297		public void setServiceNameSpaceURI(String serviceNameSpaceURI) {
298	0	this.serviceNameSpaceURI = serviceNameSpaceURI;
299	0	}
300		public Long getMillisToLive() {
301	8	return this.millisToLive;
302		}
303		public void setMillisToLive(Long millisToLive) {
304	2	this.millisToLive = millisToLive;
305	2	}
306		public Boolean getBusSecurity() {
307	8	return this.busSecurity;
308		}
309		public void setBusSecurity(Boolean busSecurity) {
310	7	this.busSecurity = busSecurity;
311	7	}
312
313		/**
314		* @return the servicePath
315		*/
316		public String getServicePath() {
317	0	return this.servicePath;
318		}
319
320		/**
321		* @param servicePath the servicePath to set
322		*/
323		public void setServicePath(String servicePath) {
324	0	this.servicePath = servicePath;
325	0	}
326
327		public String toString() {
328	0	return ReflectionToStringBuilder.toString(this);
329		}
330
331		@Override
332		public boolean equals(Object object) {
333	0	return EqualsBuilder.reflectionEquals(object, this);
334		}
335
336		@Override
337		public int hashCode() {
338	0	return HashCodeBuilder.reflectionHashCode(this);
339		}
340
341
342		}