Examples with ReportingTask org.apache.nifi.reporting.ReportingTask used on opensource projects

Example 1 with ReportingTask

use of org.apache.nifi.reporting.ReportingTask in project nifi by apache.

the class DtoFactory method createReportingTaskDto.

public ReportingTaskDTO createReportingTaskDto(final ReportingTaskNode reportingTaskNode) {
    final BundleCoordinate bundleCoordinate = reportingTaskNode.getBundleCoordinate();
    final List<Bundle> compatibleBundles = ExtensionManager.getBundles(reportingTaskNode.getCanonicalClassName()).stream().filter(bundle -> {
        final BundleCoordinate coordinate = bundle.getBundleDetails().getCoordinate();
        return bundleCoordinate.getGroup().equals(coordinate.getGroup()) && bundleCoordinate.getId().equals(coordinate.getId());
    }).collect(Collectors.toList());
    final ReportingTaskDTO dto = new ReportingTaskDTO();
    dto.setId(reportingTaskNode.getIdentifier());
    dto.setName(reportingTaskNode.getName());
    dto.setType(reportingTaskNode.getCanonicalClassName());
    dto.setBundle(createBundleDto(bundleCoordinate));
    dto.setSchedulingStrategy(reportingTaskNode.getSchedulingStrategy().name());
    dto.setSchedulingPeriod(reportingTaskNode.getSchedulingPeriod());
    dto.setState(reportingTaskNode.getScheduledState().name());
    dto.setActiveThreadCount(reportingTaskNode.getActiveThreadCount());
    dto.setAnnotationData(reportingTaskNode.getAnnotationData());
    dto.setComments(reportingTaskNode.getComments());
    dto.setPersistsState(reportingTaskNode.getReportingTask().getClass().isAnnotationPresent(Stateful.class));
    dto.setRestricted(reportingTaskNode.isRestricted());
    dto.setDeprecated(reportingTaskNode.isDeprecated());
    dto.setExtensionMissing(reportingTaskNode.isExtensionMissing());
    dto.setMultipleVersionsAvailable(compatibleBundles.size() > 1);
    final Map<String, String> defaultSchedulingPeriod = new HashMap<>();
    defaultSchedulingPeriod.put(SchedulingStrategy.TIMER_DRIVEN.name(), SchedulingStrategy.TIMER_DRIVEN.getDefaultSchedulingPeriod());
    defaultSchedulingPeriod.put(SchedulingStrategy.CRON_DRIVEN.name(), SchedulingStrategy.CRON_DRIVEN.getDefaultSchedulingPeriod());
    dto.setDefaultSchedulingPeriod(defaultSchedulingPeriod);
    // sort a copy of the properties
    final Map<PropertyDescriptor, String> sortedProperties = new TreeMap<>(new Comparator<PropertyDescriptor>() {

        @Override
        public int compare(final PropertyDescriptor o1, final PropertyDescriptor o2) {
            return Collator.getInstance(Locale.US).compare(o1.getName(), o2.getName());
        }
    });
    sortedProperties.putAll(reportingTaskNode.getProperties());
    // get the property order from the reporting task
    final ReportingTask reportingTask = reportingTaskNode.getReportingTask();
    final Map<PropertyDescriptor, String> orderedProperties = new LinkedHashMap<>();
    final List<PropertyDescriptor> descriptors = reportingTask.getPropertyDescriptors();
    if (descriptors != null && !descriptors.isEmpty()) {
        for (final PropertyDescriptor descriptor : descriptors) {
            orderedProperties.put(descriptor, null);
        }
    }
    orderedProperties.putAll(sortedProperties);
    // build the descriptor and property dtos
    dto.setDescriptors(new LinkedHashMap<String, PropertyDescriptorDTO>());
    dto.setProperties(new LinkedHashMap<String, String>());
    for (final Map.Entry<PropertyDescriptor, String> entry : orderedProperties.entrySet()) {
        final PropertyDescriptor descriptor = entry.getKey();
        // store the property descriptor
        dto.getDescriptors().put(descriptor.getName(), createPropertyDescriptorDto(descriptor, null));
        // determine the property value - don't include sensitive properties
        String propertyValue = entry.getValue();
        if (propertyValue != null && descriptor.isSensitive()) {
            propertyValue = SENSITIVE_VALUE_MASK;
        }
        // set the property value
        dto.getProperties().put(descriptor.getName(), propertyValue);
    }
    // add the validation errors
    final Collection<ValidationResult> validationErrors = reportingTaskNode.getValidationErrors();
    if (validationErrors != null && !validationErrors.isEmpty()) {
        final List<String> errors = new ArrayList<>();
        for (final ValidationResult validationResult : validationErrors) {
            errors.add(validationResult.toString());
        }
        dto.setValidationErrors(errors);
    }
    return dto;
}

Example 2 with ReportingTask

use of org.apache.nifi.reporting.ReportingTask in project nifi by apache.

the class ControllerFacade method getResources.

public List<Resource> getResources() {
    final List<Resource> resources = new ArrayList<>();
    resources.add(ResourceFactory.getFlowResource());
    resources.add(ResourceFactory.getSystemResource());
    resources.add(ResourceFactory.getControllerResource());
    resources.add(ResourceFactory.getCountersResource());
    resources.add(ResourceFactory.getProvenanceResource());
    resources.add(ResourceFactory.getPoliciesResource());
    resources.add(ResourceFactory.getTenantResource());
    resources.add(ResourceFactory.getProxyResource());
    resources.add(ResourceFactory.getResourceResource());
    resources.add(ResourceFactory.getSiteToSiteResource());
    // restricted components
    resources.add(ResourceFactory.getRestrictedComponentsResource());
    Arrays.stream(RequiredPermission.values()).forEach(requiredPermission -> resources.add(ResourceFactory.getRestrictedComponentsResource(requiredPermission)));
    final ProcessGroup root = flowController.getGroup(flowController.getRootGroupId());
    // include the root group
    final Resource rootResource = root.getResource();
    resources.add(rootResource);
    resources.add(ResourceFactory.getDataResource(rootResource));
    resources.add(ResourceFactory.getPolicyResource(rootResource));
    // add each processor
    for (final ProcessorNode processor : root.findAllProcessors()) {
        final Resource processorResource = processor.getResource();
        resources.add(processorResource);
        resources.add(ResourceFactory.getDataResource(processorResource));
        resources.add(ResourceFactory.getPolicyResource(processorResource));
    }
    // add each label
    for (final Label label : root.findAllLabels()) {
        final Resource labelResource = label.getResource();
        resources.add(labelResource);
        resources.add(ResourceFactory.getPolicyResource(labelResource));
    }
    // add each process group
    for (final ProcessGroup processGroup : root.findAllProcessGroups()) {
        final Resource processGroupResource = processGroup.getResource();
        resources.add(processGroupResource);
        resources.add(ResourceFactory.getDataResource(processGroupResource));
        resources.add(ResourceFactory.getPolicyResource(processGroupResource));
    }
    // add each remote process group
    for (final RemoteProcessGroup remoteProcessGroup : root.findAllRemoteProcessGroups()) {
        final Resource remoteProcessGroupResource = remoteProcessGroup.getResource();
        resources.add(remoteProcessGroupResource);
        resources.add(ResourceFactory.getDataResource(remoteProcessGroupResource));
        resources.add(ResourceFactory.getPolicyResource(remoteProcessGroupResource));
    }
    // add each input port
    for (final Port inputPort : root.findAllInputPorts()) {
        final Resource inputPortResource = inputPort.getResource();
        resources.add(inputPortResource);
        resources.add(ResourceFactory.getDataResource(inputPortResource));
        resources.add(ResourceFactory.getPolicyResource(inputPortResource));
        if (inputPort instanceof RootGroupPort) {
            resources.add(ResourceFactory.getDataTransferResource(inputPortResource));
        }
    }
    // add each output port
    for (final Port outputPort : root.findAllOutputPorts()) {
        final Resource outputPortResource = outputPort.getResource();
        resources.add(outputPortResource);
        resources.add(ResourceFactory.getDataResource(outputPortResource));
        resources.add(ResourceFactory.getPolicyResource(outputPortResource));
        if (outputPort instanceof RootGroupPort) {
            resources.add(ResourceFactory.getDataTransferResource(outputPortResource));
        }
    }
    // add each controller service
    final Consumer<ControllerServiceNode> csConsumer = controllerService -> {
        final Resource controllerServiceResource = controllerService.getResource();
        resources.add(controllerServiceResource);
        resources.add(ResourceFactory.getPolicyResource(controllerServiceResource));
    };
    flowController.getAllControllerServices().forEach(csConsumer);
    root.findAllControllerServices().forEach(csConsumer);
    // add each reporting task
    for (final ReportingTaskNode reportingTask : flowController.getAllReportingTasks()) {
        final Resource reportingTaskResource = reportingTask.getResource();
        resources.add(reportingTaskResource);
        resources.add(ResourceFactory.getPolicyResource(reportingTaskResource));
    }
    // add each template
    for (final Template template : root.findAllTemplates()) {
        final Resource templateResource = template.getResource();
        resources.add(templateResource);
        resources.add(ResourceFactory.getPolicyResource(templateResource));
    }
    return resources;
}

Example 3 with ReportingTask

use of org.apache.nifi.reporting.ReportingTask in project nifi by apache.

the class TestStandardProcessScheduler method setup.

@Before
public void setup() throws InitializationException {
    final Map<String, String> overrideProperties = new HashMap<>();
    overrideProperties.put(NiFiProperties.ADMINISTRATIVE_YIELD_DURATION, "2 millis");
    overrideProperties.put(NiFiProperties.PROCESSOR_SCHEDULING_TIMEOUT, "10 millis");
    this.nifiProperties = NiFiProperties.createBasicNiFiProperties(propsFile, overrideProperties);
    // load the system bundle
    systemBundle = SystemBundle.create(nifiProperties);
    ExtensionManager.discoverExtensions(systemBundle, Collections.emptySet());
    scheduler = new StandardProcessScheduler(new FlowEngine(1, "Unit Test", true), Mockito.mock(FlowController.class), null, stateMgrProvider, nifiProperties);
    scheduler.setSchedulingAgent(SchedulingStrategy.TIMER_DRIVEN, Mockito.mock(SchedulingAgent.class));
    reportingTask = new TestReportingTask();
    final ReportingInitializationContext config = new StandardReportingInitializationContext(UUID.randomUUID().toString(), "Test", SchedulingStrategy.TIMER_DRIVEN, "5 secs", Mockito.mock(ComponentLog.class), null, nifiProperties, null);
    reportingTask.initialize(config);
    final ValidationContextFactory validationContextFactory = new StandardValidationContextFactory(null, variableRegistry);
    final TerminationAwareLogger logger = Mockito.mock(TerminationAwareLogger.class);
    final ReloadComponent reloadComponent = Mockito.mock(ReloadComponent.class);
    final LoggableComponent<ReportingTask> loggableComponent = new LoggableComponent<>(reportingTask, systemBundle.getBundleDetails().getCoordinate(), logger);
    taskNode = new StandardReportingTaskNode(loggableComponent, UUID.randomUUID().toString(), null, scheduler, validationContextFactory, new StandardComponentVariableRegistry(variableRegistry), reloadComponent);
    controller = Mockito.mock(FlowController.class);
    final ConcurrentMap<String, ProcessorNode> processorMap = new ConcurrentHashMap<>();
    Mockito.doAnswer(new Answer<ProcessorNode>() {

        @Override
        public ProcessorNode answer(InvocationOnMock invocation) throws Throwable {
            final String id = invocation.getArgumentAt(0, String.class);
            return processorMap.get(id);
        }
    }).when(controller).getProcessorNode(Mockito.anyString());
    Mockito.doAnswer(new Answer<Object>() {

        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            final ProcessorNode procNode = invocation.getArgumentAt(0, ProcessorNode.class);
            processorMap.putIfAbsent(procNode.getIdentifier(), procNode);
            return null;
        }
    }).when(controller).onProcessorAdded(Mockito.any(ProcessorNode.class));
    rootGroup = new MockProcessGroup(controller);
    Mockito.when(controller.getGroup(Mockito.anyString())).thenReturn(rootGroup);
}

Example 4 with ReportingTask

use of org.apache.nifi.reporting.ReportingTask in project nifi by apache.

the class ReportingTaskingInitializer method initialize.

@Override
public void initialize(ConfigurableComponent component) throws InitializationException {
    ReportingTask reportingTask = (ReportingTask) component;
    ReportingInitializationContext context = new MockReportingInitializationContext();
    try (NarCloseable narCloseable = NarCloseable.withComponentNarLoader(component.getClass(), context.getIdentifier())) {
        reportingTask.initialize(context);
    }
}

Example 5 with ReportingTask

use of org.apache.nifi.reporting.ReportingTask in project nifi by apache.

the class StandardProcessScheduler method unschedule.

@Override
public void unschedule(final ReportingTaskNode taskNode) {
    final LifecycleState lifecycleState = getLifecycleState(requireNonNull(taskNode), false);
    if (!lifecycleState.isScheduled()) {
        return;
    }
    taskNode.verifyCanStop();
    final SchedulingAgent agent = getSchedulingAgent(taskNode.getSchedulingStrategy());
    final ReportingTask reportingTask = taskNode.getReportingTask();
    taskNode.setScheduledState(ScheduledState.STOPPED);
    final Runnable unscheduleReportingTaskRunnable = new Runnable() {

        @Override
        public void run() {
            final ConfigurationContext configurationContext = taskNode.getConfigurationContext();
            synchronized (lifecycleState) {
                lifecycleState.setScheduled(false);
                try {
                    try (final NarCloseable x = NarCloseable.withComponentNarLoader(reportingTask.getClass(), reportingTask.getIdentifier())) {
                        ReflectionUtils.invokeMethodsWithAnnotation(OnUnscheduled.class, reportingTask, configurationContext);
                    }
                } catch (final Exception e) {
                    final Throwable cause = e instanceof InvocationTargetException ? e.getCause() : e;
                    final ComponentLog componentLog = new SimpleProcessLogger(reportingTask.getIdentifier(), reportingTask);
                    componentLog.error("Failed to invoke @OnUnscheduled method due to {}", cause);
                    LOG.error("Failed to invoke the @OnUnscheduled methods of {} due to {}; administratively yielding this ReportingTask and will attempt to schedule it again after {}", reportingTask, cause.toString(), administrativeYieldDuration);
                    LOG.error("", cause);
                    try {
                        Thread.sleep(administrativeYieldMillis);
                    } catch (final InterruptedException ie) {
                    }
                }
                agent.unschedule(taskNode, lifecycleState);
                if (lifecycleState.getActiveThreadCount() == 0 && lifecycleState.mustCallOnStoppedMethods()) {
                    ReflectionUtils.quietlyInvokeMethodsWithAnnotation(OnStopped.class, reportingTask, configurationContext);
                }
            }
        }
    };
    componentLifeCycleThreadPool.execute(unscheduleReportingTaskRunnable);
}