Examples with StandardProcessContext org.apache.nifi.processor.StandardProcessContext used on opensource projects

Example 1 with StandardProcessContext

use of org.apache.nifi.processor.StandardProcessContext in project nifi by apache.

the class StandardProcessGroup method shutdown.

private void shutdown(final ProcessGroup procGroup) {
    for (final ProcessorNode node : procGroup.getProcessors()) {
        try (final NarCloseable x = NarCloseable.withComponentNarLoader(node.getProcessor().getClass(), node.getIdentifier())) {
            final StandardProcessContext processContext = new StandardProcessContext(node, controllerServiceProvider, encryptor, getStateManager(node.getIdentifier()), () -> false);
            ReflectionUtils.quietlyInvokeMethodsWithAnnotation(OnShutdown.class, node.getProcessor(), processContext);
        }
    }
    for (final RemoteProcessGroup rpg : procGroup.getRemoteProcessGroups()) {
        rpg.shutdown();
    }
    // Recursively shutdown child groups.
    for (final ProcessGroup group : procGroup.getProcessGroups()) {
        shutdown(group);
    }
}

Example 2 with StandardProcessContext

use of org.apache.nifi.processor.StandardProcessContext in project nifi by apache.

the class StandardProcessScheduler method startProcessor.

/**
 * Starts the given {@link Processor} by invoking its
 * {@link ProcessorNode#start(ScheduledExecutorService, long, org.apache.nifi.processor.ProcessContext, Runnable)}
 * method.
 *
 * @see StandardProcessorNode#start(ScheduledExecutorService, long, org.apache.nifi.processor.ProcessContext, Runnable)
 */
@Override
public synchronized CompletableFuture<Void> startProcessor(final ProcessorNode procNode, final boolean failIfStopping) {
    final LifecycleState lifecycleState = getLifecycleState(requireNonNull(procNode), true);
    final StandardProcessContext processContext = new StandardProcessContext(procNode, this.controllerServiceProvider, this.encryptor, getStateManager(procNode.getIdentifier()), lifecycleState::isTerminated);
    final CompletableFuture<Void> future = new CompletableFuture<>();
    final SchedulingAgentCallback callback = new SchedulingAgentCallback() {

        @Override
        public void trigger() {
            lifecycleState.clearTerminationFlag();
            getSchedulingAgent(procNode).schedule(procNode, lifecycleState);
            future.complete(null);
        }

        @Override
        public Future<?> scheduleTask(final Callable<?> task) {
            lifecycleState.incrementActiveThreadCount(null);
            return componentMonitoringThreadPool.submit(task);
        }

        @Override
        public void onTaskComplete() {
            lifecycleState.decrementActiveThreadCount(null);
        }
    };
    LOG.info("Starting {}", procNode);
    procNode.start(this.componentMonitoringThreadPool, this.administrativeYieldMillis, processContext, callback, failIfStopping);
    return future;
}

Example 3 with StandardProcessContext

use of org.apache.nifi.processor.StandardProcessContext in project nifi by apache.

the class TestStandardProcessorNode method testStart.

@Test(timeout = 10000)
public void testStart() throws InterruptedException {
    final ProcessorThatThrowsExceptionOnScheduled processor = new ProcessorThatThrowsExceptionOnScheduled();
    final String uuid = UUID.randomUUID().toString();
    ProcessorInitializationContext initContext = new StandardProcessorInitializationContext(uuid, null, null, null, null);
    processor.initialize(initContext);
    final ReloadComponent reloadComponent = Mockito.mock(ReloadComponent.class);
    final BundleCoordinate coordinate = Mockito.mock(BundleCoordinate.class);
    final LoggableComponent<Processor> loggableComponent = new LoggableComponent<>(processor, coordinate, null);
    final StandardProcessorNode procNode = new StandardProcessorNode(loggableComponent, uuid, createValidationContextFactory(), null, null, NiFiProperties.createBasicNiFiProperties(null, null), new StandardComponentVariableRegistry(VariableRegistry.EMPTY_REGISTRY), reloadComponent);
    final ScheduledExecutorService taskScheduler = new FlowEngine(1, "TestClasspathResources", true);
    final StandardProcessContext processContext = new StandardProcessContext(procNode, null, null, null, () -> false);
    final SchedulingAgentCallback schedulingAgentCallback = new SchedulingAgentCallback() {

        @Override
        public void onTaskComplete() {
        }

        @Override
        public Future<?> scheduleTask(final Callable<?> task) {
            return taskScheduler.submit(task);
        }

        @Override
        public void trigger() {
            Assert.fail("Should not have completed");
        }
    };
    procNode.start(taskScheduler, 20000L, processContext, schedulingAgentCallback, true);
    Thread.sleep(1000L);
    assertEquals(1, processor.onScheduledCount);
    assertEquals(1, processor.onUnscheduledCount);
    assertEquals(1, processor.onStoppedCount);
}

Example 4 with StandardProcessContext

use of org.apache.nifi.processor.StandardProcessContext in project nifi by apache.

the class StandardProcessGroup method removeProcessor.

@Override
public void removeProcessor(final ProcessorNode processor) {
    boolean removed = false;
    final String id = requireNonNull(processor).getIdentifier();
    writeLock.lock();
    try {
        if (!processors.containsKey(id)) {
            throw new IllegalStateException(processor.getIdentifier() + " is not a member of this Process Group");
        }
        processor.verifyCanDelete();
        for (final Connection conn : processor.getConnections()) {
            conn.verifyCanDelete();
        }
        try (final NarCloseable x = NarCloseable.withComponentNarLoader(processor.getProcessor().getClass(), processor.getIdentifier())) {
            final StandardProcessContext processContext = new StandardProcessContext(processor, controllerServiceProvider, encryptor, getStateManager(processor.getIdentifier()), () -> false);
            ReflectionUtils.quietlyInvokeMethodsWithAnnotation(OnRemoved.class, processor.getProcessor(), processContext);
        } catch (final Exception e) {
            throw new ComponentLifeCycleException("Failed to invoke 'OnRemoved' methods of processor with id " + processor.getIdentifier(), e);
        }
        for (final Map.Entry<PropertyDescriptor, String> entry : processor.getProperties().entrySet()) {
            final PropertyDescriptor descriptor = entry.getKey();
            if (descriptor.getControllerServiceDefinition() != null) {
                final String value = entry.getValue() == null ? descriptor.getDefaultValue() : entry.getValue();
                if (value != null) {
                    final ControllerServiceNode serviceNode = controllerServiceProvider.getControllerServiceNode(value);
                    if (serviceNode != null) {
                        serviceNode.removeReference(processor);
                    }
                }
            }
        }
        processors.remove(id);
        onComponentModified();
        flowController.onProcessorRemoved(processor);
        LogRepositoryFactory.getRepository(processor.getIdentifier()).removeAllObservers();
        final StateManagerProvider stateManagerProvider = flowController.getStateManagerProvider();
        scheduler.submitFrameworkTask(new Runnable() {

            @Override
            public void run() {
                stateManagerProvider.onComponentRemoved(processor.getIdentifier());
            }
        });
        // must copy to avoid a concurrent modification
        final Set<Connection> copy = new HashSet<>(processor.getConnections());
        for (final Connection conn : copy) {
            removeConnection(conn);
        }
        removed = true;
        LOG.info("{} removed from flow", processor);
    } finally {
        if (removed) {
            try {
                ExtensionManager.removeInstanceClassLoader(id);
            } catch (Throwable t) {
            }
        }
        writeLock.unlock();
    }
}

Example 5 with StandardProcessContext

use of org.apache.nifi.processor.StandardProcessContext in project nifi by apache.

the class StandardProcessScheduler method stopProcessor.

/**
 * Stops the given {@link Processor} by invoking its
 * {@link ProcessorNode#stop(ScheduledExecutorService, org.apache.nifi.processor.ProcessContext, SchedulingAgent, LifecycleState)}
 * method.
 *
 * @see StandardProcessorNode#stop(ScheduledExecutorService, org.apache.nifi.processor.ProcessContext, SchedulingAgent, LifecycleState)
 */
@Override
public synchronized CompletableFuture<Void> stopProcessor(final ProcessorNode procNode) {
    final LifecycleState lifecycleState = getLifecycleState(procNode, false);
    StandardProcessContext processContext = new StandardProcessContext(procNode, this.controllerServiceProvider, this.encryptor, getStateManager(procNode.getIdentifier()), lifecycleState::isTerminated);
    LOG.info("Stopping {}", procNode);
    return procNode.stop(this, this.componentLifeCycleThreadPool, processContext, getSchedulingAgent(procNode), lifecycleState);
}