Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

RiceApplicationConfigurationMediationServiceImpl

0/113

0/50

3.25

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