@Override
public void enableControllerService(final ControllerService service) {
final ControllerServiceConfiguration configuration =
context.getConfiguration(service.getIdentifier());
if (configuration == null) {
throw new IllegalArgumentException("Controller Service " + service + " is not known");
}
if (configuration.isEnabled()) {
throw new IllegalStateException(
"Cannot enable Controller Service " + service + " because it is not disabled");
}
try {
final ConfigurationContext configContext =
new MockConfigurationContext(service, configuration.getProperties(), context);
ReflectionUtils.invokeMethodsWithAnnotation(OnEnabled.class, service, configContext);
} catch (final InvocationTargetException ite) {
ite.getCause().printStackTrace();
Assert.fail("Failed to enable Controller Service " + service + " due to " + ite.getCause());
} catch (final Exception e) {
e.printStackTrace();
Assert.fail("Failed to enable Controller Service " + service + " due to " + e);
}
configuration.setEnabled(true);
}
@Override
public boolean isControllerServiceEnabled(final ControllerService service) {
final ControllerServiceConfiguration configuration =
context.getConfiguration(service.getIdentifier());
if (configuration == null) {
throw new IllegalArgumentException("Controller Service " + service + " is not known");
}
return configuration.isEnabled();
}
@Override
public void removeControllerService(final ControllerService service) {
disableControllerService(service);
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnRemoved.class, service);
} catch (final Exception e) {
e.printStackTrace();
Assert.fail("Failed to remove Controller Service " + service + " due to " + e);
}
context.removeControllerService(service);
}
private ControllerServiceConfiguration getConfigToUpdate(final ControllerService service) {
final ControllerServiceConfiguration configuration =
context.getConfiguration(service.getIdentifier());
if (configuration == null) {
throw new IllegalArgumentException("Controller Service " + service + " is not known");
}
if (configuration.isEnabled()) {
throw new IllegalStateException(
"Controller service " + service + " cannot be modified because it is not disabled");
}
return configuration;
}
@Override
public void disableControllerService(final ControllerService service) {
final ControllerServiceConfiguration configuration =
context.getConfiguration(service.getIdentifier());
if (configuration == null) {
throw new IllegalArgumentException("Controller Service " + service + " is not known");
}
if (!configuration.isEnabled()) {
throw new IllegalStateException(
"Controller service " + service + " cannot be disabled because it is not enabled");
}
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnDisabled.class, service);
} catch (final Exception e) {
e.printStackTrace();
Assert.fail("Failed to disable Controller Service " + service + " due to " + e);
}
configuration.setEnabled(false);
}
@Override
public void addControllerService(
final String identifier,
final ControllerService service,
final Map<String, String> properties)
throws InitializationException {
// hold off on failing due to deprecated annotation for now... will introduce later.
// for ( final Method method : service.getClass().getMethods() ) {
// if ( method.isAnnotationPresent(org.apache.nifi.controller.annotation.OnConfigured.class) ) {
// Assert.fail("Controller Service " + service + " is using deprecated Annotation " +
// org.apache.nifi.controller.annotation.OnConfigured.class + " for method " + method);
// }
// }
final MockComponentLog logger = new MockComponentLog(identifier, service);
controllerServiceLoggers.put(identifier, logger);
final MockStateManager serviceStateManager = new MockStateManager(service);
final MockControllerServiceInitializationContext initContext =
new MockControllerServiceInitializationContext(
requireNonNull(service), requireNonNull(identifier), logger, serviceStateManager);
controllerServiceStateManagers.put(identifier, serviceStateManager);
initContext.addControllerServices(context);
service.initialize(initContext);
final Map<PropertyDescriptor, String> resolvedProps = new HashMap<>();
for (final Map.Entry<String, String> entry : properties.entrySet()) {
resolvedProps.put(service.getPropertyDescriptor(entry.getKey()), entry.getValue());
}
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnAdded.class, service);
} catch (final InvocationTargetException
| IllegalAccessException
| IllegalArgumentException e) {
throw new InitializationException(e);
}
context.addControllerService(identifier, service, resolvedProps, null);
}
@Override
public void assertValid(final ControllerService service) {
final StateManager serviceStateManager =
controllerServiceStateManagers.get(service.getIdentifier());
if (serviceStateManager == null) {
throw new IllegalStateException(
"Controller Service has not been added to this TestRunner via the #addControllerService method");
}
final ValidationContext validationContext =
new MockValidationContext(context, serviceStateManager)
.getControllerServiceValidationContext(service);
final Collection<ValidationResult> results =
context.getControllerService(service.getIdentifier()).validate(validationContext);
for (final ValidationResult result : results) {
if (!result.isValid()) {
Assert.fail(
"Expected Controller Service to be valid but it is invalid due to: "
+ result.toString());
}
}
}
@Override
public void setRelationshipUnavailable(final Relationship relationship) {
final Set<Relationship> unavailable = new HashSet<>(context.getUnavailableRelationships());
unavailable.add(relationship);
context.setUnavailableRelationships(unavailable);
}
@Override
public void removeConnection(Relationship relationship) {
context.removeConnection(relationship);
}
@Override
public void run(
final int iterations,
final boolean stopOnFinish,
final boolean initialize,
final long runWait) {
if (iterations < 1) {
throw new IllegalArgumentException();
}
context.assertValid();
context.enableExpressionValidation();
try {
if (initialize) {
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnScheduled.class, processor, context);
} catch (final Exception e) {
e.printStackTrace();
Assert.fail(
"Could not invoke methods annotated with @OnScheduled annotation due to: " + e);
}
}
final ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
@SuppressWarnings("unchecked")
final Future<Throwable>[] futures = new Future[iterations];
for (int i = 0; i < iterations; i++) {
final Future<Throwable> future = executorService.submit(new RunProcessor());
futures[i] = future;
}
executorService.shutdown();
try {
executorService.awaitTermination(runWait, TimeUnit.MILLISECONDS);
} catch (final InterruptedException e1) {
}
int finishedCount = 0;
boolean unscheduledRun = false;
for (final Future<Throwable> future : futures) {
try {
final Throwable thrown = future.get(); // wait for the result
if (thrown != null) {
throw new AssertionError(thrown);
}
if (++finishedCount == 1) {
unscheduledRun = true;
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnUnscheduled.class, processor, context);
} catch (final Exception e) {
Assert.fail(
"Could not invoke methods annotated with @OnUnscheduled annotation due to: " + e);
}
}
} catch (final Exception e) {
}
}
if (!unscheduledRun) {
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnUnscheduled.class, processor, context);
} catch (final Exception e) {
Assert.fail(
"Could not invoke methods annotated with @OnUnscheduled annotation due to: " + e);
}
}
if (stopOnFinish) {
try {
ReflectionUtils.invokeMethodsWithAnnotation(OnStopped.class, processor, context);
} catch (final Exception e) {
Assert.fail("Could not invoke methods annotated with @OnStopped annotation due to: " + e);
}
}
} finally {
context.disableExpressionValidation();
}
}
@Override
public <T extends ControllerService> T getControllerService(
final String identifier, final Class<T> serviceType) {
final ControllerService service = context.getControllerService(identifier);
return serviceType.cast(service);
}
@Override
public void assertValid() {
context.assertValid();
}
@Override
public ValidationResult setProperty(
final PropertyDescriptor descriptor, final AllowableValue value) {
return context.setProperty(descriptor, value.getValue());
}
@Override
public ValidationResult setProperty(final PropertyDescriptor descriptor, final String value) {
return context.setProperty(descriptor, value);
}
@Override
public ValidationResult setProperty(final String propertyName, final String propertyValue) {
return context.setProperty(propertyName, propertyValue);
}
@Override
public void setAnnotationData(final String annotationData) {
context.setAnnotationData(annotationData);
}
@Override
public void assertNotValid() {
Assert.assertFalse(
"Processor appears to be valid but expected it to be invalid", context.isValid());
}
@Override
public void setIncomingConnection(boolean hasIncomingConnection) {
context.setIncomingConnection(hasIncomingConnection);
}
@Override
public void setNonLoopConnection(final boolean hasNonLoopConnection) {
context.setNonLoopConnection(hasNonLoopConnection);
}
@Override
public ControllerService getControllerService(final String identifier) {
return context.getControllerService(identifier);
}
@Override
public void addConnection(Relationship relationship) {
context.addConnection(relationship);
}
@Override
public boolean removeProperty(PropertyDescriptor descriptor) {
return context.removeProperty(descriptor);
}
@Override
public void setValidateExpressionUsage(final boolean validate) {
context.setValidateExpressionUsage(validate);
}
