Coverage Report

Coverage Report - org.kuali.rice.kns.service.impl.RiceApplicationConfigurationMediationServiceImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

RiceApplicationConfigurationMediationServiceImpl

0/122

0/56

3.562

 /*
  * Copyright 2005-2009 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.kns.service.impl;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import javax.xml.namespace.QName;
 
 import org.kuali.rice.core.api.component.Component;
 import org.kuali.rice.core.api.namespace.Namespace;
 import org.kuali.rice.core.api.namespace.NamespaceService;
 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
 import org.kuali.rice.core.util.MaxAgeSoftReference;
 import org.kuali.rice.kns.datadictionary.AttributeDefinition;
 import org.kuali.rice.kns.service.KNSServiceLocatorInternal;
 import org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService;
 import org.kuali.rice.kns.service.RiceApplicationConfigurationService;
 import org.kuali.rice.ksb.api.KsbApiServiceLocator;
 import org.kuali.rice.ksb.api.bus.Endpoint;
 
 //@Transactional
 public class RiceApplicationConfigurationMediationServiceImpl implements RiceApplicationConfigurationMediationService {
     private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RiceApplicationConfigurationMediationServiceImpl.class);
      
  // Max age defined in seconds
     protected int configurationParameterCacheMaxSize = 200;
     protected int configurationParameterCacheMaxAgeSeconds = 3600;
     protected int nonDatabaseComponentsCacheMaxSize = 50;
     protected int nonDatabaseComponentsCacheMaxAgeSeconds = 3600;
 
     protected final HashMap<String,MaxAgeSoftReference<String>> configurationParameterCache = new HashMap<String,MaxAgeSoftReference<String>>( configurationParameterCacheMaxSize );
     protected final HashMap<String,MaxAgeSoftReference<List<Component>>> nonDatabaseComponentsCache = new HashMap<String,MaxAgeSoftReference<List<Component>>>( nonDatabaseComponentsCacheMaxSize );
     protected final HashMap<String,MaxAgeSoftReference<RiceApplicationConfigurationService>> responsibleServiceByPackageClass = new HashMap<String,MaxAgeSoftReference<RiceApplicationConfigurationService>>( configurationParameterCacheMaxSize );
     
     public String getConfigurationParameter( String namespaceCode, String parameterName ){
             
             String parameterValue = null;
             if ( namespaceCode != null ) {
                 String parameterKey = (new StringBuffer(namespaceCode).append("|").append(parameterName)).toString();
                 parameterValue = getParameterValueFromConfigurationParameterCache( parameterKey );
                 if ( parameterValue != null ) {
                 return parameterValue;
             }
                 NamespaceService nsService = KNSServiceLocatorInternal.getNamespaceService();
                 final String applicationNamespaceCode;
                 Namespace namespace = nsService.getNamespace(namespaceCode);
                 if (namespace != null) {
                     applicationNamespaceCode = namespace.getApplicationId();
                 } else {
                     applicationNamespaceCode = namespaceCode;
                 }
                         if (applicationNamespaceCode != null) {
                                 RiceApplicationConfigurationService rac = findRiceApplicationConfigurationService(applicationNamespaceCode);
                                 if (rac != null) {
                                         parameterValue = rac.getConfigurationParameter(parameterName);
                                 }
                         }
                         if (parameterValue != null){
                                 synchronized (configurationParameterCache) {
                                     configurationParameterCache.put( parameterKey, new MaxAgeSoftReference<String>( configurationParameterCacheMaxAgeSeconds, parameterValue ) );
                                 }
                         }
                 }
             return parameterValue;
     }
     
 
     protected String getParameterValueFromConfigurationParameterCache(String parameterKey) {
         MaxAgeSoftReference<String> parameterValue = configurationParameterCache.get( parameterKey );
         if ( parameterValue != null ) {
             return parameterValue.get();
         }
         return null;
     }
     
     protected List<Component> getComponentListFromNonDatabaseComponentsCache(String nonDatabaseServiceNameKey) {
         MaxAgeSoftReference<List<Component>> nonDatabaseComponent = nonDatabaseComponentsCache.get( nonDatabaseServiceNameKey );
         if ( nonDatabaseComponent != null ) {
             return nonDatabaseComponent.get();
         }
         return null;
     }
 
     public List<Component> getNonDatabaseComponents() {
             
                 // TODO I think the code that's below here will actually pull in more than
                 // one reference to a particular application's config service if it is deployed
                 // in a cluster, it needs to only pull a single RiceApplicationConfigurationService
                 // implementation per application id.  Also, may want to consider load balancing
                 // and failover in those cases?  It might be best to try and utilize the client-side
                 // KSB proxies that handle a lot of this stuff for us
             
 
             Set<QName> serviceNames = findApplicationConfigurationServices();
                 
                 List<Component> nonDatabaseComponents = new ArrayList<Component>();
                 //add cache per serviceName
                 for ( QName serviceName : serviceNames ) {
                     List<Component> nonDatabaseComponentFromCache = this.getComponentListFromNonDatabaseComponentsCache(serviceName.toString());
                 if (nonDatabaseComponentFromCache != null) {
                     nonDatabaseComponents.addAll(nonDatabaseComponentFromCache);
                 } else {
                             RiceApplicationConfigurationService rac = findRiceApplicationConfigurationService(serviceName);
                             try {
                                 if (rac != null) {
                                         nonDatabaseComponents.addAll(rac.getNonDatabaseComponents());
                                         synchronized (nonDatabaseComponentsCache) {
                                 nonDatabaseComponentsCache.put(serviceName.toString(), new MaxAgeSoftReference<List<Component>>( nonDatabaseComponentsCacheMaxAgeSeconds, rac.getNonDatabaseComponents() ));
                                             }
                                 }
                             } catch (Exception e) {
                                 //TODO : Need a better way to catch if service is not active (404 error)
                                 LOG.warn("Invalid RiceApplicationConfigurationService with name: " + serviceName + ".  ");
                             }
                 }
                         
                 }
                 
                 return nonDatabaseComponents;
     }
     
     protected Set<QName> findApplicationConfigurationServices() {
             Set<QName> names = new HashSet<QName>();
             List<Endpoint> allEndpoints = KsbApiServiceLocator.getServiceBus().getAllEndpoints();
             for (Endpoint endpoint : allEndpoints) {
                     QName serviceName = endpoint.getServiceConfiguration().getServiceName();
                     if (serviceName.getLocalPart().equals(KNSServiceLocatorInternal.RICE_APPLICATION_CONFIGURATION_SERVICE)) {
                             names.add(serviceName);
                     }
             }
             return names;
     }
     
     protected RiceApplicationConfigurationService findRiceApplicationConfigurationService(QName serviceName) {
             try {
                     return (RiceApplicationConfigurationService) GlobalResourceLoader.getService(serviceName);
             } catch (Exception e) {
                     // if the service doesn't exist an exception is thrown
                     LOG.warn("Failed to locate RiceApplicationConfigurationService with name: " + serviceName,e);
             }
             return null;
     }
     
     protected RiceApplicationConfigurationService findRiceApplicationConfigurationService(String namespace) {
             try {
                     return (RiceApplicationConfigurationService)GlobalResourceLoader.getService(new QName(namespace, KNSServiceLocatorInternal.RICE_APPLICATION_CONFIGURATION_SERVICE));
             } catch (Exception e) {
                     // if the service doesn't exist an exception is thrown
                     LOG.warn("Failed to locate RiceApplicationConfigurationService with namespace: " + namespace,e);
             }
             return null;
     }
 
 
     public void setConfigurationParameterCacheMaxSize(
             int configurationParameterCacheMaxSize) {
         this.configurationParameterCacheMaxSize = configurationParameterCacheMaxSize;
     }
 
 
     public void setConfigurationParameterCacheMaxAgeSeconds(
             int configurationParameterCacheMaxAgeSeconds) {
         this.configurationParameterCacheMaxAgeSeconds = configurationParameterCacheMaxAgeSeconds;
     }
 
 
     public void setNonDatabaseComponentsCacheMaxSize(
             int nonDatabaseComponentsCacheMaxSize) {
         this.nonDatabaseComponentsCacheMaxSize = nonDatabaseComponentsCacheMaxSize;
     }
 
 
     public void setNonDatabaseComponentsCacheMaxAgeSeconds(
             int nonDatabaseComponentsCacheMaxAgeSeconds) {
         this.nonDatabaseComponentsCacheMaxAgeSeconds = nonDatabaseComponentsCacheMaxAgeSeconds;
     }
     
     /**
      * Call each available service to see if it's responsible for the given package.  When found, cache the result
      * to prevent need for future service lookups for the same package.
      */
     protected RiceApplicationConfigurationService findServiceResponsibleForPackageOrClass( String packageOrClassName ) {
             if ( LOG.isDebugEnabled() ) {
                     LOG.debug( "Checking for app config service responsible for: " + packageOrClassName );
             }
             RiceApplicationConfigurationService racService = null;
             MaxAgeSoftReference<RiceApplicationConfigurationService> ref = responsibleServiceByPackageClass.get(packageOrClassName);
             if ( ref != null ) {
                     racService = ref.get();
                     if ( racService != null ) {
                     if ( LOG.isDebugEnabled() ) {
                             LOG.debug( "Service found in cache: " + racService.getClass().getName() );
                     }                                                
                     }
             }
             if ( racService == null ) {
                 Set<QName> serviceNames = findApplicationConfigurationServices();
                         for ( QName serviceName : serviceNames ) {
                                 racService = findRiceApplicationConfigurationService(serviceName);
                                 if ( racService != null ) {
                                 
                                         try {
                                                 if ( racService.isResponsibleForPackage(packageOrClassName) ) {
                                                 if ( LOG.isDebugEnabled() ) {
                                                         LOG.debug( "Found responsible class on bus with name: " + serviceName );
                                                 }                    
                                                         responsibleServiceByPackageClass.put(packageOrClassName, new MaxAgeSoftReference<RiceApplicationConfigurationService>( configurationParameterCacheMaxAgeSeconds, racService) );
                                                         break;
                                                 } else {
                                                         racService = null; // null it out in case this is the last iteration
                                                 }
                                         } catch (Exception e) {
                                                 LOG.warn( "Assuming this racService is not responsible for the package or class.  racService: "  +
                                                                 racService.toString() + " ;  packageOrClassName: " + packageOrClassName);
                                         }
                                 }
                         }
             }
             if ( racService == null ) {
                     LOG.warn( "Unable to find service which handles package/class: " + packageOrClassName + " -- returning null." );
             }
                 return racService;
     }
     
     /**
      * @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseInquiryUrl(java.lang.String)
      */
     public String getBaseInquiryUrl(String businessObjectClassName) {
             RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
             if ( racService != null ) {
                     return racService.getBaseInquiryUrl(businessObjectClassName);
             }
             return null;
     }
 
     /**
      * @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseLookupUrl(java.lang.String)
      */
     public String getBaseLookupUrl(String businessObjectClassName) {
             RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
             if ( racService != null ) {
                     return racService.getBaseLookupUrl(businessObjectClassName);
             }
             return null;
     }
     
     /**
      * @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseHelpUrl(java.lang.String)
      */
     public String getBaseHelpUrl(String businessObjectClassName) {
             RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
             if ( racService != null ) {
                     return racService.getBaseHelpUrl(businessObjectClassName);
             }
             return null;
     }
     
     /**
      * @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBusinessObjectAttributeDefinition(java.lang.String, java.lang.String)
      */
     public AttributeDefinition getBusinessObjectAttributeDefinition(String businessObjectClassName, String attributeName) {
             if ( LOG.isDebugEnabled() ) {
                     LOG.debug( "Querying for an AttributeDefinition for: " + businessObjectClassName + " / " + attributeName );
             }
             RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
             if ( racService != null ) {
                     return racService.getBusinessObjectAttributeDefinition(businessObjectClassName, attributeName);
             }
             return null;
     }
 }

1		/*
2		* Copyright 2005-2009 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License"); you may not use this file except in
5		* compliance with the License. You may obtain a copy of the License at
6		*
7		* http://www.opensource.org/licenses/ecl2.php
8		*
9		* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS
10		* IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
11		* language governing permissions and limitations under the License.
12		*/
13		package org.kuali.rice.kns.service.impl;
14
15		import java.util.ArrayList;
16		import java.util.HashMap;
17		import java.util.HashSet;
18		import java.util.List;
19		import java.util.Set;
20
21		import javax.xml.namespace.QName;
22
23		import org.kuali.rice.core.api.component.Component;
24		import org.kuali.rice.core.api.namespace.Namespace;
25		import org.kuali.rice.core.api.namespace.NamespaceService;
26		import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
27		import org.kuali.rice.core.util.MaxAgeSoftReference;
28		import org.kuali.rice.kns.datadictionary.AttributeDefinition;
29		import org.kuali.rice.kns.service.KNSServiceLocatorInternal;
30		import org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService;
31		import org.kuali.rice.kns.service.RiceApplicationConfigurationService;
32		import org.kuali.rice.ksb.api.KsbApiServiceLocator;
33		import org.kuali.rice.ksb.api.bus.Endpoint;
34
35		//@Transactional
36	0	public class RiceApplicationConfigurationMediationServiceImpl implements RiceApplicationConfigurationMediationService {
37	0	private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RiceApplicationConfigurationMediationServiceImpl.class);
38
39		// Max age defined in seconds
40	0	protected int configurationParameterCacheMaxSize = 200;
41	0	protected int configurationParameterCacheMaxAgeSeconds = 3600;
42	0	protected int nonDatabaseComponentsCacheMaxSize = 50;
43	0	protected int nonDatabaseComponentsCacheMaxAgeSeconds = 3600;
44
45	0	protected final HashMap<String,MaxAgeSoftReference<String>> configurationParameterCache = new HashMap<String,MaxAgeSoftReference<String>>( configurationParameterCacheMaxSize );
46	0	protected final HashMap<String,MaxAgeSoftReference<List<Component>>> nonDatabaseComponentsCache = new HashMap<String,MaxAgeSoftReference<List<Component>>>( nonDatabaseComponentsCacheMaxSize );
47	0	protected final HashMap<String,MaxAgeSoftReference<RiceApplicationConfigurationService>> responsibleServiceByPackageClass = new HashMap<String,MaxAgeSoftReference<RiceApplicationConfigurationService>>( configurationParameterCacheMaxSize );
48
49		public String getConfigurationParameter( String namespaceCode, String parameterName ){
50
51	0	String parameterValue = null;
52	0	if ( namespaceCode != null ) {
53	0	String parameterKey = (new StringBuffer(namespaceCode).append("\|").append(parameterName)).toString();
54	0	parameterValue = getParameterValueFromConfigurationParameterCache( parameterKey );
55	0	if ( parameterValue != null ) {
56	0	return parameterValue;
57		}
58	0	NamespaceService nsService = KNSServiceLocatorInternal.getNamespaceService();
59		final String applicationNamespaceCode;
60	0	Namespace namespace = nsService.getNamespace(namespaceCode);
61	0	if (namespace != null) {
62	0	applicationNamespaceCode = namespace.getApplicationId();
63		} else {
64	0	applicationNamespaceCode = namespaceCode;
65		}
66	0	if (applicationNamespaceCode != null) {
67	0	RiceApplicationConfigurationService rac = findRiceApplicationConfigurationService(applicationNamespaceCode);
68	0	if (rac != null) {
69	0	parameterValue = rac.getConfigurationParameter(parameterName);
70		}
71		}
72	0	if (parameterValue != null){
73	0	synchronized (configurationParameterCache) {
74	0	configurationParameterCache.put( parameterKey, new MaxAgeSoftReference<String>( configurationParameterCacheMaxAgeSeconds, parameterValue ) );
75	0	}
76		}
77		}
78	0	return parameterValue;
79		}
80
81
82		protected String getParameterValueFromConfigurationParameterCache(String parameterKey) {
83	0	MaxAgeSoftReference<String> parameterValue = configurationParameterCache.get( parameterKey );
84	0	if ( parameterValue != null ) {
85	0	return parameterValue.get();
86		}
87	0	return null;
88		}
89
90		protected List<Component> getComponentListFromNonDatabaseComponentsCache(String nonDatabaseServiceNameKey) {
91	0	MaxAgeSoftReference<List<Component>> nonDatabaseComponent = nonDatabaseComponentsCache.get( nonDatabaseServiceNameKey );
92	0	if ( nonDatabaseComponent != null ) {
93	0	return nonDatabaseComponent.get();
94		}
95	0	return null;
96		}
97
98		public List<Component> getNonDatabaseComponents() {
99
100		// TODO I think the code that's below here will actually pull in more than
101		// one reference to a particular application's config service if it is deployed
102		// in a cluster, it needs to only pull a single RiceApplicationConfigurationService
103		// implementation per application id. Also, may want to consider load balancing
104		// and failover in those cases? It might be best to try and utilize the client-side
105		// KSB proxies that handle a lot of this stuff for us
106
107
108	0	Set<QName> serviceNames = findApplicationConfigurationServices();
109
110	0	List<Component> nonDatabaseComponents = new ArrayList<Component>();
111		//add cache per serviceName
112	0	for ( QName serviceName : serviceNames ) {
113	0	List<Component> nonDatabaseComponentFromCache = this.getComponentListFromNonDatabaseComponentsCache(serviceName.toString());
114	0	if (nonDatabaseComponentFromCache != null) {
115	0	nonDatabaseComponents.addAll(nonDatabaseComponentFromCache);
116		} else {
117	0	RiceApplicationConfigurationService rac = findRiceApplicationConfigurationService(serviceName);
118		try {
119	0	if (rac != null) {
120	0	nonDatabaseComponents.addAll(rac.getNonDatabaseComponents());
121	0	synchronized (nonDatabaseComponentsCache) {
122	0	nonDatabaseComponentsCache.put(serviceName.toString(), new MaxAgeSoftReference<List<Component>>( nonDatabaseComponentsCacheMaxAgeSeconds, rac.getNonDatabaseComponents() ));
123	0	}
124		}
125	0	} catch (Exception e) {
126		//TODO : Need a better way to catch if service is not active (404 error)
127	0	LOG.warn("Invalid RiceApplicationConfigurationService with name: " + serviceName + ". ");
128	0	}
129		}
130
131	0	}
132
133	0	return nonDatabaseComponents;
134		}
135
136		protected Set<QName> findApplicationConfigurationServices() {
137	0	Set<QName> names = new HashSet<QName>();
138	0	List<Endpoint> allEndpoints = KsbApiServiceLocator.getServiceBus().getAllEndpoints();
139	0	for (Endpoint endpoint : allEndpoints) {
140	0	QName serviceName = endpoint.getServiceConfiguration().getServiceName();
141	0	if (serviceName.getLocalPart().equals(KNSServiceLocatorInternal.RICE_APPLICATION_CONFIGURATION_SERVICE)) {
142	0	names.add(serviceName);
143		}
144	0	}
145	0	return names;
146		}
147
148		protected RiceApplicationConfigurationService findRiceApplicationConfigurationService(QName serviceName) {
149		try {
150	0	return (RiceApplicationConfigurationService) GlobalResourceLoader.getService(serviceName);
151	0	} catch (Exception e) {
152		// if the service doesn't exist an exception is thrown
153	0	LOG.warn("Failed to locate RiceApplicationConfigurationService with name: " + serviceName,e);
154		}
155	0	return null;
156		}
157
158		protected RiceApplicationConfigurationService findRiceApplicationConfigurationService(String namespace) {
159		try {
160	0	return (RiceApplicationConfigurationService)GlobalResourceLoader.getService(new QName(namespace, KNSServiceLocatorInternal.RICE_APPLICATION_CONFIGURATION_SERVICE));
161	0	} catch (Exception e) {
162		// if the service doesn't exist an exception is thrown
163	0	LOG.warn("Failed to locate RiceApplicationConfigurationService with namespace: " + namespace,e);
164		}
165	0	return null;
166		}
167
168
169		public void setConfigurationParameterCacheMaxSize(
170		int configurationParameterCacheMaxSize) {
171	0	this.configurationParameterCacheMaxSize = configurationParameterCacheMaxSize;
172	0	}
173
174
175		public void setConfigurationParameterCacheMaxAgeSeconds(
176		int configurationParameterCacheMaxAgeSeconds) {
177	0	this.configurationParameterCacheMaxAgeSeconds = configurationParameterCacheMaxAgeSeconds;
178	0	}
179
180
181		public void setNonDatabaseComponentsCacheMaxSize(
182		int nonDatabaseComponentsCacheMaxSize) {
183	0	this.nonDatabaseComponentsCacheMaxSize = nonDatabaseComponentsCacheMaxSize;
184	0	}
185
186
187		public void setNonDatabaseComponentsCacheMaxAgeSeconds(
188		int nonDatabaseComponentsCacheMaxAgeSeconds) {
189	0	this.nonDatabaseComponentsCacheMaxAgeSeconds = nonDatabaseComponentsCacheMaxAgeSeconds;
190	0	}
191
192		/**
193		* Call each available service to see if it's responsible for the given package. When found, cache the result
194		* to prevent need for future service lookups for the same package.
195		*/
196		protected RiceApplicationConfigurationService findServiceResponsibleForPackageOrClass( String packageOrClassName ) {
197	0	if ( LOG.isDebugEnabled() ) {
198	0	LOG.debug( "Checking for app config service responsible for: " + packageOrClassName );
199		}
200	0	RiceApplicationConfigurationService racService = null;
201	0	MaxAgeSoftReference<RiceApplicationConfigurationService> ref = responsibleServiceByPackageClass.get(packageOrClassName);
202	0	if ( ref != null ) {
203	0	racService = ref.get();
204	0	if ( racService != null ) {
205	0	if ( LOG.isDebugEnabled() ) {
206	0	LOG.debug( "Service found in cache: " + racService.getClass().getName() );
207		}
208		}
209		}
210	0	if ( racService == null ) {
211	0	Set<QName> serviceNames = findApplicationConfigurationServices();
212	0	for ( QName serviceName : serviceNames ) {
213	0	racService = findRiceApplicationConfigurationService(serviceName);
214	0	if ( racService != null ) {
215
216		try {
217	0	if ( racService.isResponsibleForPackage(packageOrClassName) ) {
218	0	if ( LOG.isDebugEnabled() ) {
219	0	LOG.debug( "Found responsible class on bus with name: " + serviceName );
220		}
221	0	responsibleServiceByPackageClass.put(packageOrClassName, new MaxAgeSoftReference<RiceApplicationConfigurationService>( configurationParameterCacheMaxAgeSeconds, racService) );
222	0	break;
223		} else {
224	0	racService = null; // null it out in case this is the last iteration
225		}
226	0	} catch (Exception e) {
227	0	LOG.warn( "Assuming this racService is not responsible for the package or class. racService: " +
228		racService.toString() + " ; packageOrClassName: " + packageOrClassName);
229	0	}
230		}
231		}
232		}
233	0	if ( racService == null ) {
234	0	LOG.warn( "Unable to find service which handles package/class: " + packageOrClassName + " -- returning null." );
235		}
236	0	return racService;
237		}
238
239		/**
240		* @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseInquiryUrl(java.lang.String)
241		*/
242		public String getBaseInquiryUrl(String businessObjectClassName) {
243	0	RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
244	0	if ( racService != null ) {
245	0	return racService.getBaseInquiryUrl(businessObjectClassName);
246		}
247	0	return null;
248		}
249
250		/**
251		* @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseLookupUrl(java.lang.String)
252		*/
253		public String getBaseLookupUrl(String businessObjectClassName) {
254	0	RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
255	0	if ( racService != null ) {
256	0	return racService.getBaseLookupUrl(businessObjectClassName);
257		}
258	0	return null;
259		}
260
261		/**
262		* @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBaseHelpUrl(java.lang.String)
263		*/
264		public String getBaseHelpUrl(String businessObjectClassName) {
265	0	RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
266	0	if ( racService != null ) {
267	0	return racService.getBaseHelpUrl(businessObjectClassName);
268		}
269	0	return null;
270		}
271
272		/**
273		* @see org.kuali.rice.kns.service.RiceApplicationConfigurationMediationService#getBusinessObjectAttributeDefinition(java.lang.String, java.lang.String)
274		*/
275		public AttributeDefinition getBusinessObjectAttributeDefinition(String businessObjectClassName, String attributeName) {
276	0	if ( LOG.isDebugEnabled() ) {
277	0	LOG.debug( "Querying for an AttributeDefinition for: " + businessObjectClassName + " / " + attributeName );
278		}
279	0	RiceApplicationConfigurationService racService = findServiceResponsibleForPackageOrClass(businessObjectClassName);
280	0	if ( racService != null ) {
281	0	return racService.getBusinessObjectAttributeDefinition(businessObjectClassName, attributeName);
282		}
283	0	return null;
284		}
285		}