*/
package org.opendaylight.controller.blueprint.ext;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
-import javax.annotation.Nullable;
import org.apache.aries.blueprint.di.AbstractRecipe;
import org.apache.aries.blueprint.di.ExecutionContext;
import org.apache.aries.blueprint.di.Recipe;
import org.apache.aries.blueprint.ext.DependentComponentFactoryMetadata;
import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.blueprint.BlueprintContainerRestartService;
import org.osgi.framework.ServiceReference;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.slf4j.LoggerFactory;
/**
+ * Abstract base class for a DependentComponentFactoryMetadata implementation.
+ *
* @author Thomas Pantelis
*/
abstract class AbstractDependentComponentFactoryMetadata implements DependentComponentFactoryMetadata {
- private final Logger log = LoggerFactory.getLogger(getClass());
+ @SuppressFBWarnings("SLF4J_LOGGER_SHOULD_BE_PRIVATE")
+ final Logger log = LoggerFactory.getLogger(getClass());
private final String id;
private final AtomicBoolean started = new AtomicBoolean();
private final AtomicBoolean satisfied = new AtomicBoolean();
private final AtomicBoolean restarting = new AtomicBoolean();
+ @GuardedBy("serviceRecipes")
private final List<StaticServiceReferenceRecipe> serviceRecipes = new ArrayList<>();
private volatile ExtendedBlueprintContainer container;
private volatile SatisfactionCallback satisfactionCallback;
private volatile String failureMessage;
private volatile Throwable failureCause;
- private volatile String dependendencyDesc;
+ private volatile String dependencyDesc;
+ @GuardedBy("serviceRecipes")
+ private boolean stoppedServiceRecipes;
- protected AbstractDependentComponentFactoryMetadata(String id) {
- this.id = Preconditions.checkNotNull(id);
+ protected AbstractDependentComponentFactoryMetadata(final String id) {
+ this.id = requireNonNull(id);
}
@Override
@Override
public String getDependencyDescriptor() {
- return dependendencyDesc;
+ return dependencyDesc;
}
@Override
return satisfied.get();
}
- protected abstract void startTracking();
-
- protected void setFailureMessage(String failureMessage) {
+ protected void setFailureMessage(final String failureMessage) {
setFailure(failureMessage, null);
}
- protected void setFailure(String failureMessage, Throwable failureCause) {
+ @SuppressWarnings("checkstyle:hiddenField")
+ protected void setFailure(final String failureMessage, final Throwable failureCause) {
this.failureMessage = failureMessage;
this.failureCause = failureCause;
}
- protected void setDependendencyDesc(String dependendencyDesc) {
- this.dependendencyDesc = dependendencyDesc;
+ protected void setDependencyDesc(final String dependencyDesc) {
+ this.dependencyDesc = dependencyDesc;
}
protected final ExtendedBlueprintContainer container() {
}
protected void setSatisfied() {
- if(satisfied.compareAndSet(false, true)) {
+ if (satisfied.compareAndSet(false, true)) {
satisfactionCallback.notifyChanged();
}
}
- protected void retrieveService(String name, Class<?> interfaceClass, Consumer<Object> onServiceRetrieved) {
+ protected void retrieveService(final String name, final Class<?> interfaceClass,
+ final Consumer<Object> onServiceRetrieved) {
retrieveService(name, interfaceClass.getName(), onServiceRetrieved);
}
- protected void retrieveService(String name, String interfaceName, Consumer<Object> onServiceRetrieved) {
- StaticServiceReferenceRecipe recipe = new StaticServiceReferenceRecipe(getId() + "-" + name,
- container, interfaceName);
- setDependendencyDesc(recipe.getOsgiFilter());
- serviceRecipes.add(recipe);
+ protected void retrieveService(final String name, final String interfaceName,
+ final Consumer<Object> onServiceRetrieved) {
+ synchronized (serviceRecipes) {
+ if (stoppedServiceRecipes) {
+ return;
+ }
+
+ StaticServiceReferenceRecipe recipe = new StaticServiceReferenceRecipe(getId() + "-" + name,
+ container, interfaceName);
+ setDependencyDesc(recipe.getOsgiFilter());
+ serviceRecipes.add(recipe);
- recipe.startTracking(onServiceRetrieved);
+ recipe.startTracking(onServiceRetrieved);
+ }
}
protected final String logName() {
- return (container != null ? container.getBundleContext().getBundle().getSymbolicName() : "") +
- " (" + id + ")";
+ return (container != null ? container.getBundleContext().getBundle().getSymbolicName() : "") + " (" + id + ")";
}
@Override
- public void init(ExtendedBlueprintContainer container) {
- this.container = container;
+ public void init(final ExtendedBlueprintContainer newContainer) {
+ this.container = newContainer;
log.debug("{}: In init", logName());
}
protected void onCreate() throws ComponentDefinitionException {
- if(failureMessage != null) {
+ if (failureMessage != null) {
throw new ComponentDefinitionException(failureMessage, failureCause);
}
executionContext.removePartialObject(id);
Recipe myRecipe = executionContext.getRecipe(id);
- if(myRecipe instanceof AbstractRecipe) {
+ if (myRecipe instanceof AbstractRecipe) {
log.debug("{}: setPrototype to false", logName());
((AbstractRecipe)myRecipe).setPrototype(false);
} else {
}
}
+ protected abstract void startTracking();
+
@Override
- public final void startTracking(final SatisfactionCallback satisfactionCallback) {
- if(!started.compareAndSet(false, true)) {
+ public final void startTracking(final SatisfactionCallback newSatisfactionCallback) {
+ if (!started.compareAndSet(false, true)) {
return;
}
log.debug("{}: In startTracking", logName());
- this.satisfactionCallback = satisfactionCallback;
+ this.satisfactionCallback = newSatisfactionCallback;
startTracking();
}
}
@Override
- public void destroy(Object instance) {
+ public void destroy(final Object instance) {
log.debug("{}: In destroy", logName());
stopServiceRecipes();
}
private void stopServiceRecipes() {
- for(StaticServiceReferenceRecipe recipe: serviceRecipes) {
- recipe.stop();
- }
+ synchronized (serviceRecipes) {
+ stoppedServiceRecipes = true;
+ for (StaticServiceReferenceRecipe recipe: serviceRecipes) {
+ recipe.stop();
+ }
- serviceRecipes.clear();
+ serviceRecipes.clear();
+ }
}
protected void restartContainer() {
- if(restarting.compareAndSet(false, true)) {
+ if (restarting.compareAndSet(false, true)) {
BlueprintContainerRestartService restartService = getOSGiService(BlueprintContainerRestartService.class);
- if(restartService != null) {
+ if (restartService != null) {
log.debug("{}: Restarting container", logName());
restartService.restartContainerAndDependents(container().getBundleContext().getBundle());
}
}
@SuppressWarnings("unchecked")
- @Nullable
- protected <T> T getOSGiService(Class<T> serviceInterface) {
+ protected <T> @Nullable T getOSGiService(final Class<T> serviceInterface) {
try {
ServiceReference<T> serviceReference =
container().getBundleContext().getServiceReference(serviceInterface);
- if(serviceReference == null) {
+ if (serviceReference == null) {
log.warn("{}: {} reference not found", logName(), serviceInterface.getSimpleName());
return null;
}
T service = (T)container().getService(serviceReference);
- if(service == null) {
+ if (service == null) {
// This could happen on shutdown if the service was already unregistered so we log as debug.
log.debug("{}: {} was not found", logName(), serviceInterface.getSimpleName());
}
return service;
- } catch(IllegalStateException e) {
+ } catch (final IllegalStateException e) {
// This is thrown if the BundleContext is no longer valid which is possible on shutdown so we
// log as debug.
log.debug("{}: Error obtaining {}", logName(), serviceInterface.getSimpleName(), e);
Code Review / controller.git / blobdiff