/**
* Procesar los resultados de búsqueda: acceder a algunos datos: - MetaDatos comunes como el
* nombre del contenido y versión idiomática - MetaDatos específicos: XML del tipo de contenido
*
* @param items los items a procesar
* @return
*/
private static ServiceData _resultItemToServiceData(final R01MSearchResultItem item)
throws IOException {
ServiceData itemData = new ServiceData();
// Algunos metaDatos comunes
// -------------------------
itemData.setContentName(item.getContentName());
itemData.setLang(item.getDocumentLanguage());
itemData.setLangVersionName(item.getDocumentName());
// Algunos meta-datos relevantes dependientes del tipo de contenido
// pero que son devueltos por el buscador
// ----------------------------------------------------------------
Map<String, ?> indexedMD = item.getDocumentMetaData();
itemData.setProcedureStatus(
indexedMD != null ? indexedMD.get("procedureStatus").toString() : null);
// MetaDatos específicos disponibles en un XML que hay que descargar de euskadi.net
// --------------------------------------------------------------------------------
String dataFileXML = _downloadDataFileXML(item);
if (dataFileXML != null) itemData.setDataFileXML(dataFileXML);
// Assets reusables (ZIP con el contenido)
// ---------------------------------------
Map<String, Path> assets = item.getReusableAssets();
if (CollectionUtils.hasData(assets)) itemData.setReusableAssets(assets);
return itemData;
}
public CONTAINER_TYPE withLabelInStructurePicks(final R01MLabelInStructurePick... picks) {
if (CollectionUtils.hasData(picks)) {
Collection<R01MLabelInStructurePick> picksCol = Arrays.asList(picks);
return this.withLabelInStructurePicks(picksCol);
}
return _parentType;
}
/**
* Returns a map with the labels of a certain structure indexed by their oid
*
* @param cats
* @param structureOid
* @param role
* @return
*/
private static Map<String, String> _labelsInStructure(
final List<R01MSearchResultItemStructureCatalog> cats,
final String structureOid,
final String role) {
if (CollectionUtils.isNullOrEmpty(cats)) return null;
Collection<R01MSearchResultItemStructureCatalog> roleCats =
FluentIterable.from(cats)
.filter(
new Predicate<R01MSearchResultItemStructureCatalog>() {
@Override
public boolean apply(final R01MSearchResultItemStructureCatalog cat) {
return cat.getStructureOid().equals(structureOid) && cat.getRole().equals(role);
}
})
.toList();
// Get the labels descriptions
Map<String, String> outCats = new HashMap<String, String>(roleCats.size());
Labels labels = LABELS.get(structureOid);
for (R01MSearchResultItemStructureCatalog cat : roleCats) {
String labelOid = cat.getLabelOid();
String label = labels.getByOid(labelOid);
if (label != null) outCats.put(labelOid, label);
}
return outCats;
}
/////////////////////////////////////////////////////////////////////////////////////////
// JPQL
/////////////////////////////////////////////////////////////////////////////////////////
protected String _jpqlQueryFrom(final BooleanQueryClause qryClause) {
if (qryClause == null || CollectionUtils.isNullOrEmpty(qryClause.getClauses())) {
log.warn("A filter with NO filter parameters was received... al records will be returned");
return null;
}
String dbFieldId = qryClause.getFieldId().asString();
StringBuilder outJPQL = new StringBuilder();
outJPQL.append("(");
Set<QualifiedQueryClause<? extends QueryClause>> clauses = qryClause.getClauses();
QueryClauseOccur prevClauseOccur = null;
for (Iterator<QualifiedQueryClause<? extends QueryClause>> clauseIt = clauses.iterator();
clauseIt.hasNext(); ) {
QualifiedQueryClause<? extends QueryClause> clause = clauseIt.next();
String jpqlQuery = _jpqlQueryFrom(clause.getClause());
String jpqlJoin = _jpqlJoinFor(clause.getOccur());
if (jpqlQuery != null) {
if (prevClauseOccur != null) outJPQL.append(jpqlJoin);
if (clauseIt.hasNext()) prevClauseOccur = clause.getOccur();
outJPQL.append("(");
outJPQL.append(jpqlQuery); // The clause
outJPQL.append(")");
} else {
log.error("A null lucene query was returned for field {}", dbFieldId);
}
}
outJPQL.append(")");
return outJPQL.toString();
}
/** @return the standard terms as a {@link LanguageTexts} */
public LanguageTexts getStandardTermsAsLanguageTexts() {
Collection<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();
if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
LanguageTexts outTerms = new R01MStructureLabelTermsAsLanguageTextsView(standardTerms);
return outTerms;
}
public CONTAINER_TYPE withLabelInStructurePicks(
final Collection<R01MLabelInStructurePick> picks) {
if (CollectionUtils.hasData(picks)) {
_modelObject.asStructureCatalogable().addPicks(picks);
}
return _parentType;
}
/**
* Sets the synonymous terms by language
*
* @param theSynonymousTerms The synonimousTerms to set.
*/
public void addSynonymousTerms(final Collection<R01MStructureLabelTerm> theSynonymousTerms) {
if (CollectionUtils.isNullOrEmpty(theSynonymousTerms)) return;
if (_terms == null) _terms = new HashSet<R01MStructureLabelTerm>();
// Ensure that the provided term is NOT a synonymous term and add it to the list
for (R01MStructureLabelTerm term : theSynonymousTerms) {
term.setType(R01MStructureLabelTermType.SYNONIMOUS);
_terms.add(term);
}
}
/** @return a {@link Map} with the external {@link OID}s indexed by {@link AppCode} */
public Map<AppCode, String> getExtOidsByAppCode() {
Map<AppCode, String> outMap = null;
if (CollectionUtils.hasData(_extOIDs)) {
outMap = Maps.newHashMapWithExpectedSize(_extOIDs.size());
for (R01MStructureLabelOidInApp extOid : _extOIDs) {
outMap.put(extOid.getAppCode(), extOid.getOid());
}
}
return outMap;
}
@Override
public void setNamesByLanguage(final LanguageTexts langTexts) {
if (langTexts != null) {
Set<Language> definedLangs = langTexts.getDefinedLanguages();
if (CollectionUtils.hasData(definedLangs)) {
for (Language lang : definedLangs) {
this.setStandardTermIn(lang, langTexts.get(lang));
}
}
}
}
/**
* Gets the standard descriptions
*
* @return
*/
public Set<R01MStructureLabelTerm> getStandardTerms() {
if (CollectionUtils.isNullOrEmpty(_terms)) return null;
return FluentIterable.from(_terms)
.filter(
new Predicate<R01MStructureLabelTerm>() {
@Override
public boolean apply(final R01MStructureLabelTerm term) {
return term.isStandarized();
}
})
.toSet();
}
/**
* The label terms in a language
*
* @param lang
* @return
*/
public Set<R01MStructureLabelTerm> getTermsIn(final Language lang) {
if (CollectionUtils.isNullOrEmpty(_terms)) return null;
return FluentIterable.from(_terms)
.filter(
new Predicate<R01MStructureLabelTerm>() {
@Override
public boolean apply(final R01MStructureLabelTerm term) {
return term.getLang() == lang;
}
})
.toSet();
}
/**
* @return the found entities' oids if the persistence find operation was successful or a
* PersistenteException if not
* @throws PersistenceException
*/
public <O extends OID> Collection<O> getOidsOrThrow() throws PersistenceException {
if (CollectionUtils.isNullOrEmpty(_operationExecResult)) return Lists.newArrayList();
return FluentIterable.from(_operationExecResult)
.transform(
new Function<M, O>() {
@Override
@SuppressWarnings("unchecked")
public O apply(final M entity) {
return (O) entity.getOid();
}
})
.toList();
}
/**
* Gets the standard term in a language
*
* @param
* @return
*/
public R01MStructureLabelTerm getStandardTermIn(final Language lang) {
Set<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();
if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
R01MStructureLabelTerm outTerm = null;
for (R01MStructureLabelTerm term : standardTerms) {
if (term.isStandarized() && term.getLang() == lang) {
outTerm = term;
break;
}
}
return outTerm;
}
/** @return the standard terms defined languages */
public Set<Language> getStandardTermsLanguages() {
Set<R01MStructureLabelTerm> standardTerms = this.getStandardTerms();
if (CollectionUtils.isNullOrEmpty(standardTerms)) return null;
return FluentIterable.from(standardTerms)
.transform(
new Function<R01MStructureLabelTerm, Language>() {
@Override
public Language apply(final R01MStructureLabelTerm term) {
return term.getLang();
}
})
.toSet();
}
/**
* Gets the synonymous terms in a language
*
* @param lang
* @return
*/
public Set<String> getSynonimousTermsTextIn(final Language lang) {
if (CollectionUtils.isNullOrEmpty(_terms)) return null;
return FluentIterable.from(_terms)
.filter(
new Predicate<R01MStructureLabelTerm>() {
@Override
public boolean apply(final R01MStructureLabelTerm term) {
return term.isSynomimous() && term.getLang().is(lang);
}
})
.transform(
new Function<R01MStructureLabelTerm, String>() {
@Override
public String apply(final R01MStructureLabelTerm term) {
return term.getValue();
}
})
.toSet();
}
// @After
public void tearDown() throws Exception {
AA88ClientAPI api = TestAPIBase.getClientApi(AA88ClientAPI.class);
if (CollectionUtils.hasData(_testedGuaranteesOids)) {
for (AA88GuaranteeOID oid : _testedGuaranteesOids) {
// [1]: Delete the guarantee publish requests at the DB (if exists)
Collection<AA88GuaranteePublishRequestOID> deletedGuaranteePubRequestOids =
api.guaranteesAPI()
.getForPublishRequestCRUD()
.deleteAllPublishRequestsForGuaranteeWithOid(oid);
// [2]: Delete the guarantee record at the DB
AA88Guarantee deletedGuarantee = api.guaranteesAPI().getForCRUD().delete(oid);
// [3] - Delete the guarantee zip file & folder
STORAGE_SERVICES.deleteGuaranteedUnitStorage(
api.getUserContext(),
deletedGuarantee.getSourceSystemId(),
deletedGuarantee.getGuaranteedUnitId());
}
}
}
/**
* Captures java generics to do the service interface to implementation / proxy bindings
*
* @param binder
* @param apiDef
*/
@SuppressWarnings({"unchecked"})
private static <S extends ServiceInterface> Class<S> _bindServiceInterfaceToImplOrProxy(
final Binder binder, final ServiceToImplAndProxyDef<S> serviceToImplDef) {
Class<S> serviceImplOrProxyType = null;
log.warn("\t\t> {} ", serviceToImplDef.debugInfo());
// [1] - The bean impl ia available... NO proxy is needed
if (serviceToImplDef.getBeanServiceImplType() != null) {
log.warn(
"\t\t\t>Bind {} to the BEAN IMPLEMENTATION: {} (no proxy needed)",
serviceToImplDef.getInterfaceType(),
serviceToImplDef.getBeanServiceImplType());
// The implementation is available: Bind the service implementation to the interface
// annotated with @ServicesCoreImplementation
serviceImplOrProxyType = (Class<S>) serviceToImplDef.getBeanServiceImplType();
binder
.bind(serviceToImplDef.getBeanServiceImplType())
.in(Singleton.class); // the service impl as singleton
binder
.bind(serviceToImplDef.getInterfaceType())
.to(serviceImplOrProxyType); // not annotated binding
}
// [2] The bean implementation is NOT available: use the configured (REST, EJB...) proxy impl
else {
// bind the service interface default proxy or any other if the default one is NOT present
ServicesImpl defaultServiceImpl = serviceToImplDef.getConfiguredDefaultProxyImpl();
if (serviceToImplDef.getServiceProxyImplTypeOrNullFor(defaultServiceImpl) != null) {
// the configured default proxy was found (the normal case)
serviceImplOrProxyType =
(Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(defaultServiceImpl);
binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
log.warn(
"\t\t\t>Bind {} to the DEFAULT PROXY: {}",
serviceToImplDef.getInterfaceType(),
serviceImplOrProxyType);
} else if (serviceToImplDef.getServiceProxyImplTypeOrNullFor(ServicesImpl.REST) != null) {
// the configured default proxy was not found BUT the REST impl proxy is available
serviceImplOrProxyType =
(Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(ServicesImpl.REST);
binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
log.warn(
"\t\t\t>Bind {} to the DEFAULT PROXY: {} (the default={} was NOT found so used {} instead)",
serviceToImplDef.getInterfaceType(),
ServicesImpl.REST,
defaultServiceImpl,
serviceImplOrProxyType);
} else if (CollectionUtils.hasData(serviceToImplDef.getProxyTypeByImpl())) {
// The configured proxy was not found... try to get another
ServicesImpl anyImpl =
CollectionUtils.pickOneElement(serviceToImplDef.getProxyTypeByImpl().keySet());
serviceImplOrProxyType = (Class<S>) serviceToImplDef.getServiceProxyImplTypeFor(anyImpl);
binder.bind(serviceToImplDef.getInterfaceType()).to(serviceImplOrProxyType);
log.warn(
"\t\t\t>Bind {} to the DEFAULT PROXY: {} (the default={} was NOT found so used {} instead)",
serviceToImplDef.getInterfaceType(),
anyImpl,
defaultServiceImpl,
serviceImplOrProxyType);
}
// c) bind the proxy to service impl to be used at
// ServicesClientProxyLazyLoaderGuiceMethodInterceptor
if (CollectionUtils.isNullOrEmpty(serviceToImplDef.getProxyTypeByImpl())) {
log.error(
"\t\t\t>NO proxy for {} was not found: Is there any proxy type implementing {} available in the classpath?",
serviceToImplDef.getInterfaceType(),
serviceToImplDef.getInterfaceType());
}
}
return serviceImplOrProxyType;
}
/**
* Adds a synonymous term in a language
*
* @param theSynonimousTerm
*/
public void addSynonymousTerms(final R01MStructureLabelTerm... theSynonymousTerms) {
if (CollectionUtils.isNullOrEmpty(theSynonymousTerms)) return;
Collection<R01MStructureLabelTerm> terms = CollectionUtils.of(theSynonymousTerms).asSet();
this.addSynonymousTerms(terms);
}
// @Test
public void testRefresh() {
log.warn("=============================================================");
log.warn("Test Refresh");
log.warn("=============================================================");
AA88ClientAPI api = TestAPIBase.getClientApi(AA88ClientAPI.class);
// Use a type that encapsulates all the tests
final AA88LifeCycleServicesTestHelper testHelp =
new AA88LifeCycleServicesTestHelper(api, STORAGE_SERVICES);
// [1] - Create guarantees
File testFileListsContainerFolder = new File(TEST_FILELIST_FOLDER_PATH.asAbsoluteString());
File[] testFileLists = testFileListsContainerFolder.listFiles();
Observable.from(testFileLists)
.map(
new Func1<File, AA88Guarantee>() {
@Override
public AA88Guarantee call(final File fileList) {
log.warn("\n\n\n");
log.warn(
"CREATE & DO A FIRST REFRESH for MOCK guarantee using fileList at {}",
Paths.forPaths()
.join(TEST_FILELIST_FOLDER_PATH, fileList.getName())
.asAbsoluteString());
AA88Guarantee guarantee =
testHelp.testLifeCycle(
TEST_FILELIST_FOLDER_PATH,
FileName.of(fileList.getName()),
Arrays.asList(AA88MethodToBeTested.START, AA88MethodToBeTested.REFRESH));
log.warn(
"MOCK guarantee with oid={} CREATED & REFRESHED FOR THE FIRST TIME for fileList at {}",
guarantee.getOid(),
Paths.forPaths()
.join(TEST_FILELIST_FOLDER_PATH, fileList.getName())
.asAbsoluteString());
log.warn("\n\n\n");
return guarantee;
}
})
.subscribe(
new Observer<AA88Guarantee>() {
@Override
public void onNext(final AA88Guarantee guarantee) {
_testedGuaranteesOids.add(guarantee.getOid());
}
@Override
public void onCompleted() {
log.warn("\n\n\n\n\n\n");
log.warn(
":::::::: {} test guarantees with oids={} created__________________________",
_testedGuaranteesOids.size(),
_testedGuaranteesOids);
}
@Override
public void onError(final Throwable th) {
// BEWARE!!! RxJava will catch Exception and most Error.
// Exceptions cannot be propagated out of RxJava
// ... so even if Throwables.propagate(th) is used, the exception is NEVER thrown
// outside RxJava
// the only option is to use Exceptions.throwIfFatal(th)
// (see https://github.com/ReactiveX/RxJava/issues/969)
// Exceptions.throwIfFatal(th);
th.printStackTrace(System.out);
}
});
// [2] - With the created guarantees, call refresh guarantee
if (CollectionUtils.hasData(_testedGuaranteesOids)) {
log.warn(
":::::::: With the created guarantees --> Refesh all Actives Guarantees _____________________________________________________________________");
// Call refresh all active guarantees and wait a moment to the scheduler to start
api.guaranteesAPI()
.getForLifeCycle()
.refreshAllActiveGuarantees(AA88SourceSystemID.forId("PLATEA-Internet"));
Threads.safeSleep(TimeLapse.createFor("5s"));
// Check the process
final Collection<BeingRefreshedGuarantee> refreshPendingGuarantees =
FluentIterable.from(_testedGuaranteesOids)
.transform(
new Function<AA88GuaranteeOID, BeingRefreshedGuarantee>() {
@Override
public BeingRefreshedGuarantee apply(final AA88GuaranteeOID oid) {
return new BeingRefreshedGuarantee(oid);
}
})
.toList();
long startTS = System.currentTimeMillis();
long elapsedMilis = 0;
boolean anyRefreshPendingGuarantee = false;
do {
for (BeingRefreshedGuarantee b : refreshPendingGuarantees) {
if (b.isRefreshed()) continue;
// Check that there's NO minor version in requested status
AA88Guarantee mockGuarantee = api.guaranteesAPI().getForCRUD().load(b.getOid());
if (mockGuarantee.existsMinorVersionInRequestedStatus()) {
log.warn(
"...the guarantee with oid={} unitId={} is still being refreshed (the notary is working)...give a moment to the notary to do it's work...",
mockGuarantee.getOid(),
mockGuarantee.getGuaranteedUnitId());
} else {
log.warn(
"The guarantee with oid={} unitId={} has been refreshed!... stop guaranteeing it",
mockGuarantee.getOid(),
mockGuarantee.getGuaranteedUnitId());
b.setRefreshed(true);
}
}
anyRefreshPendingGuarantee = _anyRefreshPendingGuarantee(refreshPendingGuarantees);
if (anyRefreshPendingGuarantee) {
elapsedMilis = System.currentTimeMillis() - startTS;
Threads.safeSleep(TimeLapse.createFor("5s"));
}
Assert.assertTrue(
elapsedMilis
< AA88LifeCycleServicesTestHelper.MAX_REFRESH_TIME_PER_GUARANTEE
* _testedGuaranteesOids.size());
} while (anyRefreshPendingGuarantee);
// Stop guaranteeing
for (AA88GuaranteeOID oid : _testedGuaranteesOids) {
log.warn("Stop guaranteein guarantee with oid={}", oid);
api.guaranteesAPI().getForLifeCycle().stopGuaranteeingNow(oid);
}
// Check that all guarantees has been stoped
for (AA88GuaranteeOID oid : _testedGuaranteesOids) {
AA88Guarantee mockGuarantee = api.guaranteesAPI().getForCRUD().load(oid);
Assert.assertTrue(!mockGuarantee.isActive());
}
} else {
log.warn("Could NOT create any mock guarantee!!!");
}
}
/**
* 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;
}
/**
* 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;
}