BaseDataSourceSummaryPanel.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.datasourcesummary.ui;

import java.beans.PropertyChangeEvent;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.logging.Level;
import java.util.stream.Collectors;
import javax.swing.JPanel;
import javax.swing.SwingWorker;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.datasourcesummary.datamodel.IngestModuleCheckUtil;
import org.sleuthkit.autopsy.datasourcesummary.datamodel.SleuthkitCaseProvider.SleuthkitCaseProviderException;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.DataFetchResult;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.DataFetchResult.ResultType;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.DataFetchWorker;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.DataFetchWorker.DataFetchComponents;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.EventUpdateHandler;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.LoadableComponent;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.SwingWorkerSequentialExecutor;
import org.sleuthkit.autopsy.datasourcesummary.uiutils.UpdateGovernor;
import org.sleuthkit.autopsy.ingest.IngestManager.IngestJobEvent;
import org.sleuthkit.autopsy.ingest.ModuleContentEvent;
import org.sleuthkit.autopsy.ingest.ModuleDataEvent;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.BlackboardArtifact;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.DataSource;
import org.sleuthkit.datamodel.TskCoreException;

abstract class BaseDataSourceSummaryPanel extends JPanel {

    private static final long serialVersionUID = 1L;

    private static final Logger logger = Logger.getLogger(BaseDataSourceSummaryPanel.class.getName());

    private final SwingWorkerSequentialExecutor executor = new SwingWorkerSequentialExecutor();
    private final IngestModuleCheckUtil ingestModuleCheck = new IngestModuleCheckUtil();
    private final EventUpdateHandler updateHandler;
    private final List<UpdateGovernor> governors;

    private DataSource dataSource;

    private final UpdateGovernor updateGovernor = new UpdateGovernor() {
        private boolean isInDataSource(BlackboardArtifact art, DataSource ds) {
            try {

                return (art.getDataSource() != null && art.getDataSource().getId() == ds.getId());
            } catch (TskCoreException ex) {
                logger.log(Level.WARNING, "There was an error fetching datasource for artifact.", ex);
                return false;
            }
        }

        @Override
        public boolean isRefreshRequired(ModuleDataEvent evt) {
            DataSource ds = getDataSource();
            // make sure there is an event.
            if (ds == null || evt == null) {
                return false;
            }

            //if there are no artifacts with matching datasource, return
            // if no artifacts are present, pass it on just in case there was something wrong with ModuleDataEvent
            if (evt.getArtifacts() != null
                    && !evt.getArtifacts().isEmpty()
                    && !evt.getArtifacts().stream().anyMatch((art) -> isInDataSource(art, ds))) {
                return false;
            }

            // otherwise, see if there is something that wants updates
            for (UpdateGovernor governor : governors) {
                if (governor.isRefreshRequired(evt)) {
                    return true;
                }
            }

            return false;
        }

        @Override
        public boolean isRefreshRequired(ModuleContentEvent evt) {
            DataSource ds = getDataSource();
            // make sure there is an event.
            if (ds == null || evt == null) {
                return false;
            }

            try {
                // if the underlying content has a datasource and that datasource != the 
                // current datasource, return false
                if (evt.getSource() instanceof Content
                        && ((Content) evt.getSource()).getDataSource() != null
                        && ((Content) evt.getSource()).getDataSource().getId() != ds.getId()) {
                    return false;
                }
            } catch (TskCoreException ex) {
                // on an exception, keep going for tolerance sake
                logger.log(Level.WARNING, "There was an error fetching datasource for content.", ex);
            }

            for (UpdateGovernor governor : governors) {
                if (governor.isRefreshRequired(evt)) {
                    return true;
                }
            }

            return false;
        }

        @Override
        public boolean isRefreshRequired(AbstractFile file) {
            DataSource currentDataSource = getDataSource();
            if (currentDataSource == null || file == null) {
                return false;
            }

            // make sure the file is for the current data source
            Long fileDsId = null;
            try {
                Content fileDataSource = file.getDataSource();
                fileDsId = fileDataSource.getId();
            } catch (TskCoreException ex) {
                logger.log(Level.WARNING, "Unable to get the datasource for newly added file", ex);
            }

            if (fileDsId != null && currentDataSource.getId() == fileDsId) {
                for (UpdateGovernor governor : governors) {
                    if (governor.isRefreshRequired(file)) {
                        return true;
                    }
                }
            }

            return false;
        }

        @Override
        public boolean isRefreshRequired(IngestJobEvent evt) {
            for (UpdateGovernor governor : governors) {
                if (governor.isRefreshRequired(evt)) {
                    return true;
                }
            }

            return false;
        }

        @Override
        public boolean isRefreshRequiredForCaseEvent(PropertyChangeEvent evt) {
            for (UpdateGovernor governor : governors) {
                if (governor.isRefreshRequiredForCaseEvent(evt)) {
                    return true;
                }
            }

            return false;
        }

        @Override
        public Set<Case.Events> getCaseEventUpdates() {
            // return the union of all case events sets from delegates.
            return governors.stream()
                    .filter(governor -> governor.getCaseEventUpdates() != null)
                    .flatMap(governor -> governor.getCaseEventUpdates().stream())
                    .collect(Collectors.toSet());
        }

        @Override
        public Set<IngestJobEvent> getIngestJobEventUpdates() {
            // return the union of all case events sets from delegates.
            return governors.stream()
                    .filter(governor -> governor.getIngestJobEventUpdates() != null)
                    .flatMap(governor -> governor.getIngestJobEventUpdates().stream())
                    .collect(Collectors.toSet());
        }
    };

    protected BaseDataSourceSummaryPanel(UpdateGovernor... governors) {
        this.governors = (governors == null) ? Collections.emptyList() : Arrays.asList(governors);
        this.updateHandler = new EventUpdateHandler(this::onRefresh, updateGovernor);
        this.updateHandler.register();
    }

    public void close() {
        executor.cancelRunning();
        updateHandler.unregister();
    }

    synchronized void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.executor.cancelRunning();
        onNewDataSource(this.dataSource);
    }

    protected synchronized DataSource getDataSource() {
        return this.dataSource;
    }

    protected void submit(List<? extends SwingWorker<?, ?>> workers) {
        executor.submit(workers);
    }

    synchronized void onRefresh() {
        // trigger on new data source with the current data source
        fetchInformation(this.dataSource);
    }

    protected abstract void fetchInformation(DataSource dataSource);

    protected void fetchInformation(List<DataFetchComponents<DataSource, ?>> dataFetchComponents, DataSource dataSource) {
        if (dataSource == null || !Case.isCaseOpen()) {
            dataFetchComponents.forEach((item) -> item.getResultHandler()
                    .accept(DataFetchResult.getSuccessResult(null)));
        } else {
            // create swing workers to run for each loadable item
            List<DataFetchWorker<?, ?>> workers = dataFetchComponents
                    .stream()
                    .map((components) -> new DataFetchWorker<>(components, dataSource))
                    .collect(Collectors.toList());

            // submit swing workers to run
            if (!workers.isEmpty()) {
                submit(workers);
            }
        }
    }

    protected abstract void onNewDataSource(DataSource dataSource);

    protected void onNewDataSource(
            List<DataFetchComponents<DataSource, ?>> dataFetchComponents,
            List<? extends LoadableComponent<?>> loadableComponents,
            DataSource dataSource) {
        // if no data source is present or the case is not open,
        // set results for tables to null.
        if (dataSource == null || !Case.isCaseOpen()) {
            dataFetchComponents.forEach((item) -> item.getResultHandler()
                    .accept(DataFetchResult.getSuccessResult(null)));

        } else {
            // set tables to display loading screen
            loadableComponents.forEach((table) -> table.showDefaultLoadingMessage());

            fetchInformation(dataSource);
        }
    }

    @Messages({
        "# {0} - module name",
        "BaseDataSourceSummaryPanel_defaultNotIngestMessage=The {0} ingest module has not been run on this data source."
    })
    protected String getDefaultNoIngestMessage(String moduleName) {
        return Bundle.BaseDataSourceSummaryPanel_defaultNotIngestMessage(moduleName);
    }

    protected IngestModuleCheckUtil getIngestModuleCheckUtil() {
        return this.ingestModuleCheck;
    }

    protected <T> void showResultWithModuleCheck(LoadableComponent<List<T>> component, DataFetchResult<List<T>> result, String factoryClass, String moduleName) {
        Predicate<List<T>> hasResults = (lst) -> lst != null && !lst.isEmpty();
        showResultWithModuleCheck(component, result, hasResults, factoryClass, moduleName);
    }

    protected <T> void showResultWithModuleCheck(LoadableComponent<T> component, DataFetchResult<T> result,
            Predicate<T> hasResults, String factoryClass, String moduleName) {

        if (result != null && result.getResultType() == ResultType.SUCCESS && !hasResults.test(result.getData())) {
            try {
                if (!ingestModuleCheck.isModuleIngested(getDataSource(), factoryClass)) {
                    component.showMessage(getDefaultNoIngestMessage(moduleName));
                    return;
                }
            } catch (TskCoreException | SleuthkitCaseProviderException ex) {
                logger.log(Level.WARNING, "There was an error while checking for ingest modules for datasource.", ex);
            }
        }

        component.showDataFetchResult(result);
    }
}