/**
* Finds types extending {@link ServicesCoreBootstrapGuiceModule}: {@link
* BeanImplementedServicesCoreGuiceModule}, {@link RESTImplementedServicesCoreGuiceModuleBase},
* etc if no type is found it returns null
*
* @param coreAppCode
* @param coreModule
* @return
*/
@SuppressWarnings("unchecked")
private Set<Class<? extends ServicesCoreBootstrapGuiceModule>> _findCoreGuiceModulesOrNull(
final Collection<CoreAppCode> coreAppCodes,
final Class<? extends ServicesCoreBootstrapGuiceModule> coreGuiceModuleType) {
List<String> pckgs = Lists.newLinkedList();
pckgs.add(ServicesCoreBootstrapGuiceModule.class.getPackage().getName());
pckgs.add(R01F.class.getPackage().getName()); // r01f.internal
for (CoreAppCode coreAppCode : coreAppCodes) {
pckgs.add(ServicesPackages.coreGuiceModulePackage(coreAppCode));
}
Set<?> foundBootstrapModuleTypes =
ServicesPackages.findSubTypesAt(
coreGuiceModuleType, pckgs, this.getClass().getClassLoader());
// Filter the interfaces
Set<Class<? extends ServicesCoreBootstrapGuiceModule>> outModuleTypes =
(Set<Class<? extends ServicesCoreBootstrapGuiceModule>>) foundBootstrapModuleTypes;
return FluentIterable.from(outModuleTypes)
.filter(
new Predicate<Class<? extends ServicesCoreBootstrapGuiceModule>>() {
@Override
public boolean apply(final Class<? extends ServicesCoreBootstrapGuiceModule> module) {
return ReflectionUtils.isInstanciable(module);
}
})
.toSet();
}
/**
* Returns the implementation type (REST, Bean, Mock, etc) of every services bootstrap module
* listed at [appCode].client.properties.xml file to do so, it scans the packages under {core
* appCode}.internal for types implementing {@link ServicesCoreBootstrapGuiceModule}
*
* <p>Some times a services implementation NEEDS (or DEPENDS UPON) another service implementation,
* for example, the REST services implementation NEEDS the Bean services implementation because
* REST services is only an ACCESS LAYER on top of the Bean services layer that is where the real
* services logic resides.
*
* @return
*/
public Map<CoreAppAndModule, Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>>
findBootstrapGuiceModuleTypes() {
if (_coreAppAndModules == null) return Maps.newHashMap(); // do not return a null config
Map<CoreAppAndModule, Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>>
outModuleTypes = Maps.newHashMap();
// Iterate over all the app/module collection (each app/module can have many
// ServicesCoreGuiceModules, ie: REST, Bean, etc.. one of them is the DEFAULT one)
// NOTE: If more than one implementation is found, the BEAN has the highest priority followed by
// the REST implementation
//
// for each app/module
// 1.- Find the available ServicesCoreGuiceModules
// 2.- For each found module found, try to find the needed modules
// (sometimes a module (ie REST) NEEDS another modules (ie Bean or EJB) to do delegate the
// work)
// ... this task is a bit tricky since the order in which the modules are found is important
// ... the checking of the presence of needed modules MUST be done AFTER all modules are
// processed
// Find guice modules implementing ServicesCoreGuiceModule either
// BeanImplementedServicesGuiceModuleBase, RESTImplementedServicesGuiceModuleBase,
// EJBImplementedServicesGuiceModuleBase, etc)
Map<CoreAppAndModule, Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>>
coreBootstrapModuleTypesByApp =
_findCoreBootstrapGuiceModuleTypesByAppModule(_coreAppAndModules);
Collection<BootstrapModuleDependency> dependencies = Lists.newArrayList();
for (CoreAppAndModule coreAppModule : _coreAppAndModules) {
CoreAppCode coreAppCode = coreAppModule.getAppCode();
CoreModule module = coreAppModule.getModule();
// [1] - Get the modules for the appCode
Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>
appModuleCoreBootstrapModuleTypes = coreBootstrapModuleTypesByApp.get(coreAppModule);
if (appModuleCoreBootstrapModuleTypes == null) {
log.warn(
"\t\t-{} core will NOT be bootstraped: There's NO type implementing {} at package {} or the {} package is NOT in the classpath. "
+ "If the {} core is to be bootstraped there MUST be AT LEAST a guice binding module extending {} at {} ",
coreAppModule,
ServicesCoreBootstrapGuiceModule.class,
ServicesPackages.coreGuiceModulePackage(coreAppCode),
ServicesPackages.coreGuiceModulePackage(coreAppCode),
coreAppModule,
ServicesCoreBootstrapGuiceModule.class,
ServicesPackages.coreGuiceModulePackage(coreAppCode));
continue;
}
log.warn(
"\t\t-{} core will be bootstraped with: {}",
coreAppModule,
coreBootstrapModuleTypesByApp.get(coreAppModule));
// [2] - for each found core bootstrap module try to find the needed modules (ie REST
// bootstrap modules depends on BEAN bootstrap modules)
for (Class<? extends ServicesCoreBootstrapGuiceModule> foundModuleType :
appModuleCoreBootstrapModuleTypes) {
if (ReflectionUtils.isInterface(foundModuleType)) continue;
// Check if there's any module dependency set at @ServicesCore annotation
ServicesCore servicesCoreAnnot =
ReflectionUtils.typeAnnotation(foundModuleType, ServicesCore.class);
// find the needed impl (the ServicesGuiceModule-implementing type MUST be annotated with
// ServicesGuiceModuleDependencies)
// (sometimes a service impl requires of another service impl, for example, REST services
// USES Bean services)
if (!CollectionUtils.of(servicesCoreAnnot.dependsOn()).contains(ServicesImpl.NULL)) {
CoreAppAndModule ac =
Strings.isNullOrEmpty(servicesCoreAnnot.fromOtherCoreAppCodeAndModule())
? coreAppModule // by default dependencies are at the same coreAppCode/module
: CoreAppAndModule.of(servicesCoreAnnot.fromOtherCoreAppCodeAndModule());
Collection<ServicesImpl> impls = Arrays.asList(servicesCoreAnnot.dependsOn());
BootstrapModuleDependency dependency =
new BootstrapModuleDependency(coreAppModule, foundModuleType, ac, impls);
dependencies.add(dependency);
log.warn(
"\t\t\t- Found {} CORE services bootstrap module (it has a dependency on other core component {}): {}",
foundModuleType,
dependency.debugInfo());
} else {
log.warn(
"\t\t\t- Found {} CORE services bootstrap module (no other bootstrap type dependency)",
foundModuleType);
}
} // for bindingModules
// [3] - put the core bootstrap modules in the output collection indexed by the
// appCode/component
outModuleTypes.put(coreAppModule, appModuleCoreBootstrapModuleTypes);
} // for configuredBindingModules
// Finally, make sure that the dependencies are satisfied
if (CollectionUtils.hasData(dependencies)) {
for (BootstrapModuleDependency dependency : dependencies) {
Collection<Class<? extends ServicesCoreBootstrapGuiceModule>> otherCoreMods =
outModuleTypes.get(dependency.getOtherAppAndComponent());
for (ServicesImpl depImpl : dependency.getDependencies()) {
boolean isLoaded = false;
if (CollectionUtils.hasData(otherCoreMods)) {
for (Class<? extends ServicesCoreBootstrapGuiceModule> otherCoreMod : otherCoreMods) {
if (ServicesImpl.fromBindingModule(otherCoreMod) == depImpl) {
isLoaded = true;
break;
}
}
}
if (!isLoaded)
throw new IllegalStateException(
Strings.customized(
"{} (see @{})."
+ "BUT this module could NOT be loaded."
+ "Please ensure that a {} annotated type with impl={} attribute is accesible in the run-time classpath (maybe de dependent project is NOT deployed and available at the classpath)",
dependency.debugInfo(),
ServicesCore.class.getSimpleName(),
ServicesCoreBootstrapGuiceModule.class,
depImpl));
}
}
}
// Return
return outModuleTypes;
}
/**
* Finds types extending {@link ServicesCoreBootstrapGuiceModule}: {@link
* BeanImplementedServicesCoreGuiceModule}, {@link RESTImplementedServicesCoreGuiceModuleBase},
* etc and returns them indexed by appCode / component
*
* @param coreAppCode
* @param coreModule
* @return
*/
private Map<CoreAppAndModule, Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>>
_findCoreBootstrapGuiceModuleTypesByAppModule(
final Collection<CoreAppAndModule> coreAppAndComponents) {
// get the core appcodes from the collection of core appCode/module
Collection<CoreAppCode> coreAppCodes =
FluentIterable.from(coreAppAndComponents)
.transform(
new Function<CoreAppAndModule, CoreAppCode>() {
@Override
public CoreAppCode apply(final CoreAppAndModule appAndComponent) {
return appAndComponent.getAppCode();
}
})
.toSet();
// Find the types implementing ServicesCoreGuiceModule at all the core appcodes (ie: r01t,
// aa14b, aa81b, etc)
Set<Class<? extends ServicesCoreBootstrapGuiceModule>> foundBootstrapModuleTypes =
_findCoreGuiceModulesOrNull(coreAppCodes, ServicesCoreBootstrapGuiceModule.class);
// Group the found core bootstrap module types by appCode/module
Map<CoreAppAndModule, Collection<Class<? extends ServicesCoreBootstrapGuiceModule>>>
outCoreModules = null;
if (CollectionUtils.hasData(foundBootstrapModuleTypes)) {
outCoreModules = Maps.newHashMapWithExpectedSize(coreAppCodes.size());
for (Class<? extends ServicesCoreBootstrapGuiceModule> bootstrapModuleType :
foundBootstrapModuleTypes) {
// get type appCode from the bootstrap module type's package (ie: r01t.internal.XXX) and
// it's @ServiceCore annotation
CoreAppCode appCode =
ServicesPackages.appCodeFromCoreBootstrapModuleType(
bootstrapModuleType); // use the service's core bootstrap type's package to get the
// appCode
CoreModule coreModule =
ServicesPackages.appComponentFromCoreBootstrapModuleTypeOrThrow(
bootstrapModuleType); // use the service's @ServicesCore annotation to get the
// module
CoreAppAndModule coreAppAndModule = CoreAppAndModule.of(appCode, coreModule);
Collection<Class<? extends ServicesCoreBootstrapGuiceModule>> appModuleTypes =
outCoreModules.get(coreAppAndModule);
if (appModuleTypes == null) {
appModuleTypes = Sets.newHashSet();
outCoreModules.put(coreAppAndModule, appModuleTypes);
}
appModuleTypes.add(bootstrapModuleType);
}
} else {
log.warn(
"There's NO type implementing {} in the classpath! For the CORE app codes {}, there MUST be AT LEAST a guice binding module extending {} at package {}",
ServicesCoreBootstrapGuiceModule.class.getSimpleName(),
coreAppCodes,
ServicesCoreBootstrapGuiceModule.class,
ServicesPackages.coreGuiceModulePackage(CoreAppCode.forId("[coreAppCode]")),
ServicesCoreBootstrapGuiceModule.class);
outCoreModules = Maps.newHashMap();
}
return outCoreModules;
}