private final MBeanServer mBeanServer;
private Integer maxDependencyDepth;
- DependencyResolverImpl(ModuleIdentifier currentModule,
- TransactionStatus transactionStatus, ModulesHolder modulesHolder,
- ServiceReferenceReadableRegistry readableRegistry, BindingContextProvider bindingContextProvider,
- String transactionName, MBeanServer mBeanServer) {
+ DependencyResolverImpl(final ModuleIdentifier currentModule,
+ final TransactionStatus transactionStatus, final ModulesHolder modulesHolder,
+ final ServiceReferenceReadableRegistry readableRegistry, final BindingContextProvider bindingContextProvider,
+ final String transactionName, final MBeanServer mBeanServer) {
this.bindingContextProvider = bindingContextProvider;
this.name = currentModule;
this.transactionStatus = transactionStatus;
//TODO: check for cycles
@Override
public void validateDependency(
- Class<? extends AbstractServiceInterface> expectedServiceInterface,
- ObjectName dependentReadOnlyON, JmxAttribute jmxAttribute) {
+ final Class<? extends AbstractServiceInterface> expectedServiceInterface,
+ final ObjectName dependentReadOnlyON, final JmxAttribute jmxAttribute) {
- transactionStatus.checkNotCommitted();
+ this.transactionStatus.checkNotCommitted();
if (expectedServiceInterface == null) {
throw new NullPointerException(
"Parameter 'expectedServiceInterface' is null");
// check that objectName belongs to this transaction - this should be
// stripped
// in DynamicWritableWrapper
- boolean hasTransaction = ObjectNameUtil
+ final boolean hasTransaction = ObjectNameUtil
.getTransactionName(dependentReadOnlyON) != null;
JmxAttributeValidationException.checkCondition(
!hasTransaction,
), jmxAttribute
);
- ObjectName newDependentReadOnlyON = translateServiceRefIfPossible(dependentReadOnlyON);
+ final ObjectName newDependentReadOnlyON = translateServiceRefIfPossible(dependentReadOnlyON);
- ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(newDependentReadOnlyON, ObjectNameUtil
+ final ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(newDependentReadOnlyON, ObjectNameUtil
.TYPE_MODULE);
- ModuleFactory foundFactory = modulesHolder.findModuleFactory(moduleIdentifier, jmxAttribute);
+ final ModuleFactory foundFactory = this.modulesHolder.findModuleFactory(moduleIdentifier, jmxAttribute);
- boolean implementsSI = foundFactory
+ final boolean implementsSI = foundFactory
.isModuleImplementingServiceInterface(expectedServiceInterface);
if (!implementsSI) {
- String message = String.format(
+ final String message = String.format(
"Found module factory does not expose expected service interface. "
+ "Module name is %s : %s, expected service interface %s, dependent module ON %s , "
+ "attribute %s",
throw new JmxAttributeValidationException(message, jmxAttribute);
}
synchronized (this) {
- dependencies.add(moduleIdentifier);
+ this.dependencies.add(moduleIdentifier);
}
}
// translate from serviceref to module ON
- private ObjectName translateServiceRefIfPossible(ObjectName dependentReadOnlyON) {
+ private ObjectName translateServiceRefIfPossible(final ObjectName dependentReadOnlyON) {
ObjectName translatedDependentReadOnlyON = dependentReadOnlyON;
if (ObjectNameUtil.isServiceReference(translatedDependentReadOnlyON)) {
- String serviceQName = ObjectNameUtil.getServiceQName(translatedDependentReadOnlyON);
- String refName = ObjectNameUtil.getReferenceName(translatedDependentReadOnlyON);
+ final String serviceQName = ObjectNameUtil.getServiceQName(translatedDependentReadOnlyON);
+ final String refName = ObjectNameUtil.getReferenceName(translatedDependentReadOnlyON);
translatedDependentReadOnlyON = ObjectNameUtil.withoutTransactionName( // strip again of transaction name
- readableRegistry.lookupConfigBeanByServiceInterfaceName(serviceQName, refName));
+ this.readableRegistry.lookupConfigBeanByServiceInterfaceName(serviceQName, refName));
}
return translatedDependentReadOnlyON;
}
*/
//TODO: check for cycles
@Override
- public <T> T resolveInstance(Class<T> expectedType, ObjectName dependentReadOnlyON,
- JmxAttribute jmxAttribute) {
- Module module = resolveModuleInstance(dependentReadOnlyON, jmxAttribute);
+ public <T> T resolveInstance(final Class<T> expectedType, final ObjectName dependentReadOnlyON,
+ final JmxAttribute jmxAttribute) {
+ final Module module = resolveModuleInstance(dependentReadOnlyON, jmxAttribute);
synchronized (this) {
- dependencies.add(module.getIdentifier());
+ this.dependencies.add(module.getIdentifier());
}
- AutoCloseable instance = module.getInstance();
+ final AutoCloseable instance = module.getInstance();
if (instance == null) {
- String message = String.format(
+ final String message = String.format(
"Error while %s resolving instance %s. getInstance() returned null. "
- + "Expected type %s , attribute %s", name,
+ + "Expected type %s , attribute %s", this.name,
module.getIdentifier(), expectedType, jmxAttribute
);
throw new JmxAttributeValidationException(message, jmxAttribute);
}
try {
return expectedType.cast(instance);
- } catch (ClassCastException e) {
- String message = String.format(
+ } catch (final ClassCastException e) {
+ final String message = String.format(
"Instance cannot be cast to expected type. Instance class is %s , "
+ "expected type %s , attribute %s",
instance.getClass(), expectedType, jmxAttribute
}
}
- private Module resolveModuleInstance(ObjectName dependentReadOnlyON,
- JmxAttribute jmxAttribute) {
+ private Module resolveModuleInstance(final ObjectName dependentReadOnlyON,
+ final JmxAttribute jmxAttribute) {
Preconditions.checkArgument(dependentReadOnlyON != null ,"dependentReadOnlyON");
Preconditions.checkArgument(jmxAttribute != null, "jmxAttribute");
- ObjectName translatedDependentReadOnlyON = translateServiceRefIfPossible(dependentReadOnlyON);
- transactionStatus.checkCommitStarted();
- transactionStatus.checkNotCommitted();
+ final ObjectName translatedDependentReadOnlyON = translateServiceRefIfPossible(dependentReadOnlyON);
+ this.transactionStatus.checkCommitStarted();
+ this.transactionStatus.checkNotCommitted();
- ModuleIdentifier dependentModuleIdentifier = ObjectNameUtil.fromON(
+ final ModuleIdentifier dependentModuleIdentifier = ObjectNameUtil.fromON(
translatedDependentReadOnlyON, ObjectNameUtil.TYPE_MODULE);
- return Preconditions.checkNotNull(modulesHolder.findModule(dependentModuleIdentifier, jmxAttribute));
+ return Preconditions.checkNotNull(this.modulesHolder.findModule(dependentModuleIdentifier, jmxAttribute));
}
@Override
- public boolean canReuseDependency(ObjectName objectName, JmxAttribute jmxAttribute) {
+ public boolean canReuseDependency(final ObjectName objectName, final JmxAttribute jmxAttribute) {
Preconditions.checkNotNull(objectName);
Preconditions.checkNotNull(jmxAttribute);
- Module currentModule = resolveModuleInstance(objectName, jmxAttribute);
- ModuleIdentifier identifier = currentModule.getIdentifier();
- ModuleInternalTransactionalInfo moduleInternalTransactionalInfo = modulesHolder.findModuleInternalTransactionalInfo(identifier);
+ final Module currentModule = resolveModuleInstance(objectName, jmxAttribute);
+ final ModuleIdentifier identifier = currentModule.getIdentifier();
+ final ModuleInternalTransactionalInfo moduleInternalTransactionalInfo = this.modulesHolder.findModuleInternalTransactionalInfo(identifier);
if(moduleInternalTransactionalInfo.hasOldModule()) {
- Module oldModule = moduleInternalTransactionalInfo.getOldInternalInfo().getReadableModule().getModule();
+ final Module oldModule = moduleInternalTransactionalInfo.getOldInternalInfo().getReadableModule().getModule();
return currentModule.canReuse(oldModule);
}
return false;
}
@Override
- public <T extends BaseIdentity> Class<? extends T> resolveIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass) {
+ public <T extends BaseIdentity> Class<? extends T> resolveIdentity(final IdentityAttributeRef identityRef, final Class<T> expectedBaseClass) {
final QName qName = QName.create(identityRef.getqNameOfIdentity());
- Class<?> deserialized = bindingContextProvider.getBindingContext().getIdentityClass(qName);
+ final Class<?> deserialized = this.bindingContextProvider.getBindingContext().getIdentityClass(qName);
if (deserialized == null) {
throw new IllegalStateException("Unable to retrieve identity class for " + qName + ", null response from "
- + bindingContextProvider.getBindingContext());
+ + this.bindingContextProvider.getBindingContext());
}
if (expectedBaseClass.isAssignableFrom(deserialized)) {
return (Class<T>) deserialized;
}
@Override
- public <T extends BaseIdentity> void validateIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass, JmxAttribute jmxAttribute) {
+ public <T extends BaseIdentity> void validateIdentity(final IdentityAttributeRef identityRef, final Class<T> expectedBaseClass, final JmxAttribute jmxAttribute) {
try {
resolveIdentity(identityRef, expectedBaseClass);
- } catch (Exception e) {
+ } catch (final Exception e) {
throw JmxAttributeValidationException.wrap(e, jmxAttribute);
}
}
@Override
- public int compareTo(DependencyResolverImpl o) {
- transactionStatus.checkCommitStarted();
+ public int compareTo(final DependencyResolverImpl o) {
+ this.transactionStatus.checkCommitStarted();
return Integer.compare(getMaxDependencyDepth(),
o.getMaxDependencyDepth());
}
int getMaxDependencyDepth() {
- if (maxDependencyDepth == null) {
+ if (this.maxDependencyDepth == null) {
throw new IllegalStateException("Dependency depth was not computed");
}
- return maxDependencyDepth;
+ return this.maxDependencyDepth;
}
- void countMaxDependencyDepth(DependencyResolverManager manager) {
+ void countMaxDependencyDepth(final DependencyResolverManager manager) {
// We can calculate the dependency after second phase commit was started
// Second phase commit starts after validation and validation adds the dependencies into the dependency resolver, which are necessary for the calculation
// FIXME generated code for abstract module declares validate method as non-final
// Overriding the validate would cause recreate every time instead of reuse + also possibly wrong close order if there is another module depending
- transactionStatus.checkCommitStarted();
- if (maxDependencyDepth == null) {
- maxDependencyDepth = getMaxDepth(this, manager,
+ this.transactionStatus.checkCommitStarted();
+ if (this.maxDependencyDepth == null) {
+ this.maxDependencyDepth = getMaxDepth(this, manager,
new LinkedHashSet<>());
}
}
- private static int getMaxDepth(DependencyResolverImpl impl,
- DependencyResolverManager manager,
- LinkedHashSet<ModuleIdentifier> chainForDetectingCycles) {
+ private static int getMaxDepth(final DependencyResolverImpl impl,
+ final DependencyResolverManager manager,
+ final LinkedHashSet<ModuleIdentifier> chainForDetectingCycles) {
int maxDepth = 0;
- LinkedHashSet<ModuleIdentifier> chainForDetectingCycles2 = new LinkedHashSet<>(
+ final LinkedHashSet<ModuleIdentifier> chainForDetectingCycles2 = new LinkedHashSet<>(
chainForDetectingCycles);
chainForDetectingCycles2.add(impl.getIdentifier());
- for (ModuleIdentifier dependencyName : impl.dependencies) {
- DependencyResolverImpl dependentDRI = manager
+ for (final ModuleIdentifier dependencyName : impl.dependencies) {
+ final DependencyResolverImpl dependentDRI = manager
.getOrCreate(dependencyName);
if (chainForDetectingCycles2.contains(dependencyName)) {
throw new IllegalStateException(String.format(
chainForDetectingCycles2);
dependentDRI.maxDependencyDepth = subDepth;
}
- if (subDepth + 1 > maxDepth) {
+ if ((subDepth + 1) > maxDepth) {
maxDepth = subDepth + 1;
}
}
@Override
public ModuleIdentifier getIdentifier() {
- return name;
+ return this.name;
}
@Override
- public Object getAttribute(ObjectName name, String attribute)
+ public Object getAttribute(final ObjectName name, final String attribute)
throws MBeanException, AttributeNotFoundException, InstanceNotFoundException, ReflectionException {
ObjectName newName = translateServiceRefIfPossible(name);
// add transaction name
- newName = ObjectNameUtil.withTransactionName(newName, transactionName);
- return mBeanServer.getAttribute(newName, attribute);
+ newName = ObjectNameUtil.withTransactionName(newName, this.transactionName);
+ return this.mBeanServer.getAttribute(newName, attribute);
}
@Override
- public <T> T newMXBeanProxy(ObjectName name, Class<T> interfaceClass) {
+ public <T> T newMXBeanProxy(final ObjectName name, final Class<T> interfaceClass) {
ObjectName newName = translateServiceRefIfPossible(name);
// add transaction name
- newName = ObjectNameUtil.withTransactionName(newName, transactionName);
- return JMX.newMXBeanProxy(mBeanServer, newName, interfaceClass);
+ newName = ObjectNameUtil.withTransactionName(newName, this.transactionName);
+ return JMX.newMXBeanProxy(this.mBeanServer, newName, interfaceClass);
}
}
Code Review / controller.git / blobdiff