Case.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2012-2021 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.casemodule;
 
import com.basistech.df.cybertriage.autopsy.CTIntegrationMissingDialog;
import org.sleuthkit.autopsy.featureaccess.FeatureAccessUtils;
import com.google.common.annotations.Beta;
import com.google.common.eventbus.Subscribe;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.awt.Cursor;
import org.sleuthkit.autopsy.casemodule.multiusercases.CaseNodeData;
import java.awt.Frame;
import java.awt.GraphicsEnvironment;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.UUID;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.NbBundle.Messages;
import org.openide.util.actions.CallableSystemAction;
import org.openide.windows.WindowManager;
import org.sleuthkit.autopsy.actions.OpenOutputFolderAction;
import org.sleuthkit.autopsy.appservices.AutopsyService;
import org.sleuthkit.autopsy.appservices.AutopsyService.CaseContext;
import org.sleuthkit.autopsy.casemodule.CaseMetadata.CaseMetadataException;
import org.sleuthkit.autopsy.datasourcesummary.ui.DataSourceSummaryAction;
import org.sleuthkit.autopsy.casemodule.events.AddingDataSourceEvent;
import org.sleuthkit.autopsy.casemodule.events.AddingDataSourceFailedEvent;
import org.sleuthkit.autopsy.casemodule.events.BlackBoardArtifactTagAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.BlackBoardArtifactTagDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.CommentChangedEvent;
import org.sleuthkit.autopsy.casemodule.events.ContentTagAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.ContentTagDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.DataSourceAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.DataSourceDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.DataSourceNameChangedEvent;
import org.sleuthkit.autopsy.casemodule.events.HostsAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.HostsAddedToPersonEvent;
import org.sleuthkit.autopsy.casemodule.events.HostsUpdatedEvent;
import org.sleuthkit.autopsy.casemodule.events.HostsDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.HostsRemovedFromPersonEvent;
import org.sleuthkit.autopsy.casemodule.events.OsAccountsAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.OsAccountsUpdatedEvent;
import org.sleuthkit.autopsy.casemodule.events.OsAccountsDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.OsAcctInstancesAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.PersonsAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.PersonsUpdatedEvent;
import org.sleuthkit.autopsy.casemodule.events.PersonsDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.ReportAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.TagNamesEvent.TagNamesAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.TagNamesEvent.TagNamesDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.TagNamesEvent.TagNamesUpdatedEvent;
import org.sleuthkit.autopsy.casemodule.events.TagSetsEvent.TagSetsAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.TagSetsEvent.TagSetsDeletedEvent;
import org.sleuthkit.autopsy.casemodule.multiusercases.CaseNodeData.CaseNodeDataException;
import org.sleuthkit.autopsy.casemodule.multiusercases.CoordinationServiceUtils;
import org.sleuthkit.autopsy.casemodule.services.Services;
import org.sleuthkit.autopsy.commonpropertiessearch.CommonAttributeSearchAction;
import org.sleuthkit.autopsy.communications.OpenCommVisualizationToolAction;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService.CategoryNode;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService.CoordinationServiceException;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService.Lock;
import org.sleuthkit.autopsy.core.RuntimeProperties;
import org.sleuthkit.autopsy.core.UserPreferences;
import org.sleuthkit.autopsy.core.UserPreferencesException;
import org.sleuthkit.autopsy.corecomponentinterfaces.CoreComponentControl;
import org.sleuthkit.autopsy.coreutils.DriveUtils;
import org.sleuthkit.autopsy.coreutils.FileUtil;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.MessageNotifyUtil;
import org.sleuthkit.autopsy.coreutils.NetworkUtils;
import org.sleuthkit.autopsy.coreutils.PlatformUtil;
import org.sleuthkit.autopsy.coreutils.ThreadUtils;
import org.sleuthkit.autopsy.coreutils.TimeZoneUtils;
import org.sleuthkit.autopsy.coreutils.Version;
import org.sleuthkit.autopsy.datamodel.hosts.OpenHostsAction;
import org.sleuthkit.autopsy.directorytree.DirectoryTreeTopComponent;
import org.sleuthkit.autopsy.events.AutopsyEvent;
import org.sleuthkit.autopsy.events.AutopsyEventException;
import org.sleuthkit.autopsy.events.AutopsyEventPublisher;
import org.sleuthkit.autopsy.discovery.ui.OpenDiscoveryAction;
import org.sleuthkit.autopsy.ingest.IngestJob;
import org.sleuthkit.autopsy.ingest.IngestManager;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchService;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchServiceException;
import org.sleuthkit.autopsy.machinesettings.UserMachinePreferences;
import org.sleuthkit.autopsy.progress.LoggingProgressIndicator;
import org.sleuthkit.autopsy.progress.ModalDialogProgressIndicator;
import org.sleuthkit.autopsy.progress.ProgressIndicator;
import org.sleuthkit.autopsy.timeline.OpenTimelineAction;
import org.sleuthkit.autopsy.timeline.events.TimelineEventAddedEvent;
import org.sleuthkit.datamodel.BlackboardArtifactTag;
import org.sleuthkit.datamodel.CaseDbConnectionInfo;
import org.sleuthkit.datamodel.ConcurrentDbAccessException;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ContentStreamProvider;
import org.sleuthkit.datamodel.ContentTag;
import org.sleuthkit.datamodel.DataSource;
import org.sleuthkit.datamodel.FileSystem;
import org.sleuthkit.datamodel.Image;
import org.sleuthkit.datamodel.Report;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TimelineManager;
import org.sleuthkit.datamodel.SleuthkitCaseAdminUtil;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskDataException;
import org.sleuthkit.datamodel.TskEvent;
import org.sleuthkit.datamodel.TskUnsupportedSchemaVersionException;

public class Case {
 
    private static final int CASE_LOCK_TIMEOUT_MINS = 1;
    private static final int CASE_RESOURCES_LOCK_TIMEOUT_HOURS = 1;
    private static final String APP_NAME = UserPreferences.getAppName();
    private static final String TEMP_FOLDER = "Temp";
    private static final String SINGLE_USER_CASE_DB_NAME = "autopsy.db";
    private static final String EVENT_CHANNEL_NAME = "%s-Case-Events"; //NON-NLS
    private static final String CACHE_FOLDER = "Cache"; //NON-NLS
    private static final String EXPORT_FOLDER = "Export"; //NON-NLS
    private static final String LOG_FOLDER = "Log"; //NON-NLS
    private static final String REPORTS_FOLDER = "Reports"; //NON-NLS
    private static final String CONFIG_FOLDER = "Config"; // NON-NLS
    private static final String MODULE_FOLDER = "ModuleOutput"; //NON-NLS
    private static final String CASE_ACTION_THREAD_NAME = "%s-case-action";
    private static final String CASE_RESOURCES_THREAD_NAME = "%s-manage-case-resources";
    private static final String NO_NODE_ERROR_MSG_FRAGMENT = "KeeperErrorCode = NoNode";
    private static final String CT_PROVIDER_PREFIX = "CTStandardContentProvider_";
    private static final Logger logger = Logger.getLogger(Case.class.getName());
    private static final AutopsyEventPublisher eventPublisher = new AutopsyEventPublisher();
    private static final Object caseActionSerializationLock = new Object();
    private static Future<?> backgroundOpenFileSystemsFuture = null;
    private static final ExecutorService openFileSystemsExecutor
            = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat("case-open-file-systems-%d").build());
    private static volatile Frame mainFrame;
    private static volatile Case currentCase;
    private final CaseMetadata metadata;
    private volatile ExecutorService caseActionExecutor;
    private CoordinationService.Lock caseLock;
    private SleuthkitCase caseDb;
    private final SleuthkitEventListener sleuthkitEventListener;
    private CollaborationMonitor collaborationMonitor;
    private Services caseServices;
 
    private volatile boolean hasDataSource = false;
    private volatile boolean hasData = false;
 
    /*
     * Get a reference to the main window of the desktop application to use to
     * parent pop up dialogs and initialize the application name for use in
     * changing the main window title.
     */
    static {
        if (!GraphicsEnvironment.isHeadless()) {
            WindowManager.getDefault().invokeWhenUIReady(() -> {
                mainFrame = WindowManager.getDefault().getMainWindow();
            });
        }
    }

    public enum CaseType {
 
        SINGLE_USER_CASE("Single-user case"), //NON-NLS
        MULTI_USER_CASE("Multi-user case");   //NON-NLS
 
        private final String typeName;

        public static CaseType fromString(String typeName) {
            if (typeName != null) {
                for (CaseType c : CaseType.values()) {
                    if (typeName.equalsIgnoreCase(c.toString())) {
                        return c;
                    }
                }
            }
            return null;
        }

        @Override
        public String toString() {
            return typeName;
        }

        @Messages({
            "Case_caseType_singleUser=Single-user case",
            "Case_caseType_multiUser=Multi-user case"
        })
        String getLocalizedDisplayName() {
            if (fromString(typeName) == SINGLE_USER_CASE) {
                return Bundle.Case_caseType_singleUser();
            } else {
                return Bundle.Case_caseType_multiUser();
            }
        }

        private CaseType(String typeName) {
            this.typeName = typeName;
        }

        @Deprecated
        public boolean equalsName(String otherTypeName) {
            return (otherTypeName == null) ? false : typeName.equals(otherTypeName);
        }
 
    };

    public enum Events {

        @Deprecated
        NAME,
        @Deprecated
        NUMBER,
        @Deprecated
        EXAMINER,
        ADDING_DATA_SOURCE,
        ADDING_DATA_SOURCE_FAILED,
        DATA_SOURCE_ADDED,
        DATA_SOURCE_DELETED,
        DATA_SOURCE_NAME_CHANGED,
        CURRENT_CASE,
        REPORT_ADDED,
        REPORT_DELETED,
        BLACKBOARD_ARTIFACT_TAG_ADDED,
        BLACKBOARD_ARTIFACT_TAG_DELETED,
        CONTENT_TAG_ADDED,
        CONTENT_TAG_DELETED,
        CASE_DETAILS,
        TAG_DEFINITION_CHANGED,
        TIMELINE_EVENT_ADDED,
        /*
         * An item in the central repository has had its comment modified. The
         * old value is null, the new value is string for current comment.
         */
        CR_COMMENT_CHANGED,
        OS_ACCOUNTS_ADDED,
        OS_ACCOUNTS_UPDATED,
        OS_ACCOUNTS_DELETED,
        OS_ACCT_INSTANCES_ADDED,
        HOSTS_ADDED,
        HOSTS_UPDATED,
        HOSTS_DELETED,
        PERSONS_ADDED,
        PERSONS_UPDATED,
        PERSONS_DELETED,
        HOSTS_ADDED_TO_PERSON,
        HOSTS_REMOVED_FROM_PERSON,
        
        TAG_NAMES_ADDED,
        
        TAG_NAMES_UPDATED,
        
        TAG_NAMES_DELETED,
        
        TAG_SETS_ADDED,
        
        TAG_SETS_DELETED;
 
    };

    private final class SleuthkitEventListener {
 
        @Subscribe
        public void publishTimelineEventAddedEvent(TimelineManager.TimelineEventAddedEvent event) {
            eventPublisher.publish(new TimelineEventAddedEvent(event));
        }
 
        @Subscribe
        public void publishOsAccountsAddedEvent(TskEvent.OsAccountsAddedTskEvent event) {
            hasData = true;
            eventPublisher.publish(new OsAccountsAddedEvent(event.getOsAcounts()));
        }
 
        @Subscribe
        public void publishOsAccountsUpdatedEvent(TskEvent.OsAccountsUpdatedTskEvent event) {
            eventPublisher.publish(new OsAccountsUpdatedEvent(event.getOsAcounts()));
        }
 
        @Subscribe
        public void publishOsAccountDeletedEvent(TskEvent.OsAccountsDeletedTskEvent event) {
            try {
                hasData = dbHasData();
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, "Unable to retrieve the hasData status from the db", ex);
            }
            eventPublisher.publish(new OsAccountsDeletedEvent(event.getOsAccountObjectIds()));
        }
 
        @Subscribe
        public void publishOsAccountInstancesAddedEvent(TskEvent.OsAcctInstancesAddedTskEvent event) {
            eventPublisher.publish(new OsAcctInstancesAddedEvent(event.getOsAccountInstances()));            
        }
        
        @Subscribe
        public void publishHostsAddedEvent(TskEvent.HostsAddedTskEvent event) {
            hasData = true;
            eventPublisher.publish(new HostsAddedEvent(event.getHosts()));
        }

        @Subscribe
        public void publishHostsUpdatedEvent(TskEvent.HostsUpdatedTskEvent event) {
            eventPublisher.publish(new HostsUpdatedEvent(event.getHosts()));
        }

        @Subscribe
        public void publishHostsDeletedEvent(TskEvent.HostsDeletedTskEvent event) {
            try {
                hasData = dbHasData();
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, "Unable to retrieve the hasData status from the db", ex);
            }
 
            eventPublisher.publish(new HostsDeletedEvent(event.getHostIds()));
        }

        @Subscribe
        public void publishPersonsAddedEvent(TskEvent.PersonsAddedTskEvent event) {
            eventPublisher.publish(new PersonsAddedEvent(event.getPersons()));
        }

        @Subscribe
        public void publishPersonsUpdatedEvent(TskEvent.PersonsUpdatedTskEvent event) {
            eventPublisher.publish(new PersonsUpdatedEvent(event.getPersons()));
        }

        @Subscribe
        public void publishPersonsDeletedEvent(TskEvent.PersonsDeletedTskEvent event) {
            eventPublisher.publish(new PersonsDeletedEvent(event.getPersonIds()));
        }
 
        @Subscribe
        public void publishHostsAddedToPersonEvent(TskEvent.HostsAddedToPersonTskEvent event) {
            eventPublisher.publish(new HostsAddedToPersonEvent(event.getPerson(), event.getHosts()));
        }
 
        @Subscribe
        public void publisHostsRemovedFromPersonEvent(TskEvent.HostsRemovedFromPersonTskEvent event) {
            eventPublisher.publish(new HostsRemovedFromPersonEvent(event.getPerson(), event.getHostIds()));
        }
        
        @Subscribe
        public void publicTagNamesAdded(TskEvent.TagNamesAddedTskEvent event) {
            eventPublisher.publish(new TagNamesAddedEvent(event.getTagNames()));
        }
 
        @Subscribe
        public void publicTagNamesUpdated(TskEvent.TagNamesUpdatedTskEvent event) {
            eventPublisher.publish(new TagNamesUpdatedEvent(event.getTagNames()));
        }
 
        @Subscribe
        public void publicTagNamesDeleted(TskEvent.TagNamesDeletedTskEvent event) {
            eventPublisher.publish(new TagNamesDeletedEvent(event.getTagNameIds()));
        }
 
        @Subscribe
        public void publicTagSetsAdded(TskEvent.TagSetsAddedTskEvent event) {
            eventPublisher.publish(new TagSetsAddedEvent(event.getTagSets()));
        }
 
        @Subscribe
        public void publicTagSetsDeleted(TskEvent.TagSetsDeletedTskEvent event) {
            eventPublisher.publish(new TagSetsDeletedEvent(event.getTagSetIds()));
        }
    }

    public static void addPropertyChangeListener(PropertyChangeListener listener) {
        addEventSubscriber(Stream.of(Events.values())
                .map(Events::toString)
                .collect(Collectors.toSet()), listener);
    }

    public static void removePropertyChangeListener(PropertyChangeListener listener) {
        removeEventSubscriber(Stream.of(Events.values())
                .map(Events::toString)
                .collect(Collectors.toSet()), listener);
    }

    @Deprecated
    public static void addEventSubscriber(Set<String> eventNames, PropertyChangeListener subscriber) {
        eventPublisher.addSubscriber(eventNames, subscriber);
    }

    public static void addEventTypeSubscriber(Set<Events> eventTypes, PropertyChangeListener subscriber) {
        eventTypes.forEach((Events event) -> {
            eventPublisher.addSubscriber(event.toString(), subscriber);
        });
    }

    @Deprecated
    public static void addEventSubscriber(String eventName, PropertyChangeListener subscriber) {
        eventPublisher.addSubscriber(eventName, subscriber);
    }

    public static void removeEventSubscriber(String eventName, PropertyChangeListener subscriber) {
        eventPublisher.removeSubscriber(eventName, subscriber);
    }

    public static void removeEventSubscriber(Set<String> eventNames, PropertyChangeListener subscriber) {
        eventPublisher.removeSubscriber(eventNames, subscriber);
    }

    public static void removeEventTypeSubscriber(Set<Events> eventTypes, PropertyChangeListener subscriber) {
        eventTypes.forEach((Events event) -> {
            eventPublisher.removeSubscriber(event.toString(), subscriber);
        });
    }

    public static boolean isValidName(String caseName) {
        return !(caseName.contains("\\") || caseName.contains("/") || caseName.contains(":")
                || caseName.contains("*") || caseName.contains("?") || caseName.contains("\"")
                || caseName.contains("<") || caseName.contains(">") || caseName.contains("|"));
    }

    @Deprecated
    public static void createAsCurrentCase(String caseDir, String caseDisplayName, String caseNumber, String examiner, CaseType caseType) throws CaseActionException, CaseActionCancelledException {
        createAsCurrentCase(caseType, caseDir, new CaseDetails(caseDisplayName, caseNumber, examiner, "", "", ""));
    }

    @Messages({
        "Case.exceptionMessage.emptyCaseName=Must specify a case name.",
        "Case.exceptionMessage.emptyCaseDir=Must specify a case directory path."
    })
    public static void createAsCurrentCase(CaseType caseType, String caseDir, CaseDetails caseDetails) throws CaseActionException, CaseActionCancelledException {
        if (caseDetails.getCaseDisplayName().isEmpty()) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_emptyCaseName());
        }
        if (caseDir.isEmpty()) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_emptyCaseDir());
        }
        openAsCurrentCase(new Case(caseType, caseDir, caseDetails), true);
    }

    @Messages({
        "# {0} - exception message", "Case.exceptionMessage.failedToReadMetadata=Failed to read case metadata:\n{0}.",
        "Case.exceptionMessage.cannotOpenMultiUserCaseNoSettings=Multi-user settings are missing (see Tools, Options, Multi-user tab), cannot open a multi-user case."
    })
    public static void openAsCurrentCase(String caseMetadataFilePath) throws CaseActionException {
        CaseMetadata metadata;
        try {
            metadata = new CaseMetadata(Paths.get(caseMetadataFilePath));
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_failedToReadMetadata(ex.getLocalizedMessage()), ex);
        }
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType() && !UserPreferences.getIsMultiUserModeEnabled()) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_cannotOpenMultiUserCaseNoSettings());
        }
        openAsCurrentCase(new Case(metadata), false);
    }

    public static boolean isCaseOpen() {
        return currentCase != null;
    }

    public static Case getCurrentCase() {
        try {
            return getCurrentCaseThrows();
        } catch (NoCurrentCaseException ex) {
            /*
             * Throw a runtime exception, since this is a programming error.
             */
            throw new IllegalStateException(NbBundle.getMessage(Case.class, "Case.getCurCase.exception.noneOpen"), ex);
        }
    }

    public static Case getCurrentCaseThrows() throws NoCurrentCaseException {
        /*
         * TODO (JIRA-3825): Introduce a reference counting scheme for this get
         * case method.
         */
        Case openCase = currentCase;
        if (openCase == null) {
            throw new NoCurrentCaseException(NbBundle.getMessage(Case.class, "Case.getCurCase.exception.noneOpen"));
        } else {
            return openCase;
        }
    }

    @Messages({
        "# {0} - exception message", "Case.closeException.couldNotCloseCase=Error closing case: {0}",
        "Case.progressIndicatorTitle.closingCase=Closing Case"
    })
    public static void closeCurrentCase() throws CaseActionException {
        synchronized (caseActionSerializationLock) {
            if (null == currentCase) {
                return;
            }
            Case closedCase = currentCase;
            try {
                eventPublisher.publishLocally(new AutopsyEvent(Events.CURRENT_CASE.toString(), closedCase, null));
                logger.log(Level.INFO, "Closing current case {0} ({1}) in {2}", new Object[]{closedCase.getDisplayName(), closedCase.getName(), closedCase.getCaseDirectory()}); //NON-NLS
                closedCase.doCloseCaseAction();
                logger.log(Level.INFO, "Closed current case {0} ({1}) in {2}", new Object[]{closedCase.getDisplayName(), closedCase.getName(), closedCase.getCaseDirectory()}); //NON-NLS
            } catch (CaseActionException ex) {
                logger.log(Level.SEVERE, String.format("Error closing current case %s (%s) in %s", closedCase.getDisplayName(), closedCase.getName(), closedCase.getCaseDirectory()), ex); //NON-NLS                
                throw ex;
            } finally {
                currentCase = null;
                if (RuntimeProperties.runningWithGUI()) {
                    updateGUIForCaseClosed();
                }
            }
        }
    }

    public static void deleteCurrentCase() throws CaseActionException {
        synchronized (caseActionSerializationLock) {
            if (null == currentCase) {
                return;
            }
            CaseMetadata metadata = currentCase.getMetadata();
            closeCurrentCase();
            deleteCase(metadata);
        }
    }

    @Messages({
        "Case.progressIndicatorTitle.deletingDataSource=Removing Data Source"
    })
    static void deleteDataSourceFromCurrentCase(Long dataSourceObjectID) throws CaseActionException {
        synchronized (caseActionSerializationLock) {
            if (null == currentCase) {
                return;
            }
 
            /*
             * Close the current case to release the shared case lock.
             */
            CaseMetadata caseMetadata = currentCase.getMetadata();
            closeCurrentCase();
 
            /*
             * Re-open the case with an exclusive case lock, delete the data
             * source, and close the case again, releasing the exclusive case
             * lock.
             */
            Case theCase = new Case(caseMetadata);
            theCase.doOpenCaseAction(Bundle.Case_progressIndicatorTitle_deletingDataSource(), theCase::deleteDataSource, CaseLockType.EXCLUSIVE, false, dataSourceObjectID);
 
            /*
             * Re-open the case with a shared case lock.
             */
            openAsCurrentCase(new Case(caseMetadata), false);
        }
    }

    @Messages({
        "Case.progressIndicatorTitle.deletingCase=Deleting Case",
        "Case.exceptionMessage.cannotDeleteCurrentCase=Cannot delete current case, it must be closed first.",
        "# {0} - case display name", "Case.exceptionMessage.deletionInterrupted=Deletion of the case {0} was cancelled."
    })
    public static void deleteCase(CaseMetadata metadata) throws CaseActionException {
        synchronized (caseActionSerializationLock) {
            if (null != currentCase) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_cannotDeleteCurrentCase());
            }
        }
 
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator = new ModalDialogProgressIndicator(mainFrame, Bundle.Case_progressIndicatorTitle_deletingCase());
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());
        try {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                deleteSingleUserCase(metadata, progressIndicator);
            } else {
                try {
                    deleteMultiUserCase(metadata, progressIndicator);
                } catch (InterruptedException ex) {
                    /*
                     * Note that task cancellation is not currently supported
                     * for this code path, so this catch block is not expected
                     * to be executed.
                     */
                    throw new CaseActionException(Bundle.Case_exceptionMessage_deletionInterrupted(metadata.getCaseDisplayName()), ex);
                }
            }
        } finally {
            progressIndicator.finish();
        }
    }

    @Messages({
        "Case.progressIndicatorTitle.creatingCase=Creating Case",
        "Case.progressIndicatorTitle.openingCase=Opening Case",
        "Case.exceptionMessage.cannotLocateMainWindow=Cannot locate main application window"
    })
    private static void openAsCurrentCase(Case newCurrentCase, boolean isNewCase) throws CaseActionException, CaseActionCancelledException {
        synchronized (caseActionSerializationLock) {
            if (null != currentCase) {
                try {
                    closeCurrentCase();
                } catch (CaseActionException ex) {
                    /*
                     * Notify the user and continue (the error has already been
                     * logged in closeCurrentCase.
                     */
                    MessageNotifyUtil.Message.error(ex.getLocalizedMessage());
                }
            }
            try {
                logger.log(Level.INFO, "Opening {0} ({1}) in {2} as the current case", new Object[]{newCurrentCase.getDisplayName(), newCurrentCase.getName(), newCurrentCase.getCaseDirectory()}); //NON-NLS
                String progressIndicatorTitle;
                CaseAction<ProgressIndicator, Object, Void> openCaseAction;
                if (isNewCase) {
                    progressIndicatorTitle = Bundle.Case_progressIndicatorTitle_creatingCase();
                    openCaseAction = newCurrentCase::create;
                } else {
                    progressIndicatorTitle = Bundle.Case_progressIndicatorTitle_openingCase();
                    openCaseAction = newCurrentCase::open;
                }
                newCurrentCase.doOpenCaseAction(progressIndicatorTitle, openCaseAction, CaseLockType.SHARED, true, null);
                currentCase = newCurrentCase;
                logger.log(Level.INFO, "Opened {0} ({1}) in {2} as the current case", new Object[]{newCurrentCase.getDisplayName(), newCurrentCase.getName(), newCurrentCase.getCaseDirectory()}); //NON-NLS
                if (RuntimeProperties.runningWithGUI()) {
                    updateGUIForCaseOpened(newCurrentCase);
                }
                eventPublisher.publishLocally(new AutopsyEvent(Events.CURRENT_CASE.toString(), null, currentCase));
            } catch (CaseActionCancelledException ex) {
                logger.log(Level.INFO, String.format("Cancelled opening %s (%s) in %s as the current case", newCurrentCase.getDisplayName(), newCurrentCase.getName(), newCurrentCase.getCaseDirectory())); //NON-NLS                
                throw ex;
            } catch (CaseActionException ex) {
                logger.log(Level.SEVERE, String.format("Error opening %s (%s) in %s as the current case", newCurrentCase.getDisplayName(), newCurrentCase.getName(), newCurrentCase.getCaseDirectory()), ex); //NON-NLS                
                throw ex;
            }
        }
    }

    private static String displayNameToUniqueName(String caseDisplayName) {
        /*
         * Replace all non-ASCII characters.
         */
        String uniqueCaseName = caseDisplayName.replaceAll("[^\\p{ASCII}]", "_"); //NON-NLS
 
        /*
         * Replace all control characters.
         */
        uniqueCaseName = uniqueCaseName.replaceAll("[\\p{Cntrl}]", "_"); //NON-NLS
 
        /*
         * Replace /, \, :, ?, space, ' ".
         */
        uniqueCaseName = uniqueCaseName.replaceAll("[ /?:'\"\\\\]", "_"); //NON-NLS
 
        /*
         * Make it all lowercase.
         */
        uniqueCaseName = uniqueCaseName.toLowerCase();
 
        /*
         * Add a time stamp for uniqueness.
         */
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss");
        Date date = new Date();
        uniqueCaseName = uniqueCaseName + "_" + dateFormat.format(date);
 
        return uniqueCaseName;
    }

    public static void createCaseDirectory(String caseDirPath, CaseType caseType) throws CaseActionException {
        /*
         * Check the case directory path and permissions. The case directory may
         * already exist.
         */
        File caseDir = new File(caseDirPath);
        if (caseDir.exists()) {
            if (caseDir.isFile()) {
                throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existNotDir", caseDirPath));
            } else if (!caseDir.canRead() || !caseDir.canWrite()) {
                throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existCantRW", caseDirPath));
            }
        }
 
        /*
         * Create the case directory, if it does not already exist.
         */
        if (!caseDir.mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreate", caseDirPath));
        }
 
        /*
         * Create the subdirectories of the case directory, if they do not
         * already exist. Note that multi-user cases get an extra layer of
         * subdirectories, one subdirectory per application host machine.
         */
        String hostPathComponent = "";
        if (caseType == CaseType.MULTI_USER_CASE) {
            hostPathComponent = File.separator + NetworkUtils.getLocalHostName();
        }
 
        Path exportDir = Paths.get(caseDirPath, hostPathComponent, EXPORT_FOLDER);
        if (!exportDir.toFile().mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateCaseDir", exportDir));
        }
 
        Path logsDir = Paths.get(caseDirPath, hostPathComponent, LOG_FOLDER);
        if (!logsDir.toFile().mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateCaseDir", logsDir));
        }
 
        Path cacheDir = Paths.get(caseDirPath, hostPathComponent, CACHE_FOLDER);
        if (!cacheDir.toFile().mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateCaseDir", cacheDir));
        }
 
        Path moduleOutputDir = Paths.get(caseDirPath, hostPathComponent, MODULE_FOLDER);
        if (!moduleOutputDir.toFile().mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateModDir", moduleOutputDir));
        }
 
        Path reportsDir = Paths.get(caseDirPath, hostPathComponent, REPORTS_FOLDER);
        if (!reportsDir.toFile().mkdirs()) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateReportsDir", reportsDir));
        }
    }

    static Map<Long, String> getImagePaths(SleuthkitCase db) {
        Map<Long, String> imgPaths = new HashMap<>();
        try {
            Map<Long, List<String>> imgPathsList = db.getImagePaths();
            for (Map.Entry<Long, List<String>> entry : imgPathsList.entrySet()) {
                if (entry.getValue().size() > 0) {
                    imgPaths.put(entry.getKey(), entry.getValue().get(0));
                }
            }
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, "Error getting image paths", ex); //NON-NLS
        }
        return imgPaths;
    }

    @Messages({
        "Case.creationException.couldNotAcquireResourcesLock=Failed to get lock on case resources"
    })
    private static CoordinationService.Lock acquireCaseResourcesLock(String caseDir) throws CaseActionException {
        try {
            Path caseDirPath = Paths.get(caseDir);
            String resourcesNodeName = CoordinationServiceUtils.getCaseResourcesNodePath(caseDirPath);
            Lock lock = CoordinationService.getInstance().tryGetExclusiveLock(CategoryNode.CASES, resourcesNodeName, CASE_RESOURCES_LOCK_TIMEOUT_HOURS, TimeUnit.HOURS);
            return lock;
        } catch (InterruptedException ex) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelled());
        } catch (CoordinationServiceException ex) {
            throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock(), ex);
        }
    }
 
    private static String getNameForTitle() {
        //Method should become unnecessary once technical debt story 3334 is done.
        if (UserPreferences.getAppName().equals(Version.getName())) {
            //Available version number is version number for this application
            return String.format("%s %s", UserPreferences.getAppName(), Version.getVersion());
        } else {
            return UserPreferences.getAppName();
        }
    }

    private static void updateGUIForCaseOpened(Case newCurrentCase) {
        /*
         * If the case database was upgraded for a new schema and a backup
         * database was created, notify the user.
         */
        SleuthkitCase caseDb = newCurrentCase.getSleuthkitCase();
        String backupDbPath = caseDb.getBackupDatabasePath();
        if (null != backupDbPath) {
            JOptionPane.showMessageDialog(
                    mainFrame,
                    NbBundle.getMessage(Case.class, "Case.open.msgDlg.updated.msg", backupDbPath),
                    NbBundle.getMessage(Case.class, "Case.open.msgDlg.updated.title"),
                    JOptionPane.INFORMATION_MESSAGE);
        }
 
        /*
         * Look for the files for the data sources listed in the case database
         * and give the user the opportunity to locate any that are missing.
         */
        Map<Long, String> imgPaths = getImagePaths(caseDb);
        for (Map.Entry<Long, String> entry : imgPaths.entrySet()) {
            long obj_id = entry.getKey();
            String path = entry.getValue();
            boolean fileExists = (new File(path).exists()|| DriveUtils.driveExists(path));
            if (!fileExists) {
                try {
                    DataSource ds = newCurrentCase.getSleuthkitCase().getDataSource(obj_id);
                    String hostName = StringUtils.defaultString(ds.getHost() == null ? "" : ds.getHost().getName());
                    // Using invokeAndWait means that the dialog will
                    // open on the EDT but this thread will wait for an 
                    // answer. Using invokeLater would cause this loop to
                    // end before all of the dialogs appeared.  
                    SwingUtilities.invokeAndWait(new Runnable() {
                        @Override
                        public void run() {
                            int response = JOptionPane.showConfirmDialog(
                                    mainFrame,
                                    NbBundle.getMessage(Case.class, "Case.checkImgExist.confDlg.doesntExist.msg", hostName, path),
                                    NbBundle.getMessage(Case.class, "Case.checkImgExist.confDlg.doesntExist.title"),
                                    JOptionPane.YES_NO_OPTION);
                            if (response == JOptionPane.YES_OPTION) {
                                MissingImageDialog.makeDialog(obj_id, caseDb);
                            } else {
                                logger.log(Level.SEVERE, "User proceeding with missing image files"); //NON-NLS
 
                            }
                        }
 
                    });
                } catch (InterruptedException | InvocationTargetException | TskCoreException | TskDataException ex) {
                    logger.log(Level.SEVERE, "Failed to show missing image confirmation dialog", ex); //NON-NLS 
                }
            }
        }
 
        /*
         * Enable the case-specific actions.
         */
        CallableSystemAction.get(AddImageAction.class).setEnabled(FeatureAccessUtils.canAddDataSources());
        CallableSystemAction.get(OpenHostsAction.class).setEnabled(true);
        CallableSystemAction.get(CaseCloseAction.class).setEnabled(true);
        CallableSystemAction.get(CaseDetailsAction.class).setEnabled(true);
        CallableSystemAction.get(DataSourceSummaryAction.class).setEnabled(true);
        CallableSystemAction.get(CaseDeleteAction.class).setEnabled(FeatureAccessUtils.canDeleteCurrentCase());
        CallableSystemAction.get(OpenTimelineAction.class).setEnabled(true);
        CallableSystemAction.get(OpenCommVisualizationToolAction.class).setEnabled(true);
        CallableSystemAction.get(CommonAttributeSearchAction.class).setEnabled(true);
        CallableSystemAction.get(OpenOutputFolderAction.class).setEnabled(false);
        CallableSystemAction.get(OpenDiscoveryAction.class).setEnabled(true);
 
        /*
         * Add the case to the recent cases tracker that supplies a list of
         * recent cases to the recent cases menu item and the open/create case
         * dialog.
         */
        RecentCases.getInstance().addRecentCase(newCurrentCase.getDisplayName(), newCurrentCase.getMetadata().getFilePath().toString());
        final boolean hasData = newCurrentCase.hasData();
 
        SwingUtilities.invokeLater(() -> {
            /*
             * Open the top components (windows within the main application
             * window).
             *
             * Note: If the core windows are not opened here, they will be
             * opened via the DirectoryTreeTopComponent 'propertyChange()'
             * method on a DATA_SOURCE_ADDED event.
             */
            mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
            if (hasData) {
                CoreComponentControl.openCoreWindows();
            } else {
                //ensure that the DirectoryTreeTopComponent is open so that it's listener can open the core windows including making it visible.
                DirectoryTreeTopComponent.findInstance();
            }
            mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
 
            /*
             * Reset the main window title to:
             *
             * [curent case display name] - [application name].
             */
            mainFrame.setTitle(newCurrentCase.getDisplayName() + " - " + getNameForTitle());
        });
    }
 
    /*
     * Update the GUI to to reflect the lack of a current case.
     */
    private static void updateGUIForCaseClosed() {
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> {
                /*
                 * Close the top components (windows within the main application
                 * window).
                 */
                CoreComponentControl.closeCoreWindows();
 
                /*
                 * Disable the case-specific menu items.
                 */
                CallableSystemAction.get(AddImageAction.class).setEnabled(false);
                CallableSystemAction.get(OpenHostsAction.class).setEnabled(false);
                CallableSystemAction.get(CaseCloseAction.class).setEnabled(false);
                CallableSystemAction.get(CaseDetailsAction.class).setEnabled(false);
                CallableSystemAction.get(DataSourceSummaryAction.class).setEnabled(false);
                CallableSystemAction.get(CaseDeleteAction.class).setEnabled(false);
                CallableSystemAction.get(OpenTimelineAction.class).setEnabled(false);
                CallableSystemAction.get(OpenCommVisualizationToolAction.class).setEnabled(false);
                CallableSystemAction.get(OpenOutputFolderAction.class).setEnabled(false);
                CallableSystemAction.get(CommonAttributeSearchAction.class).setEnabled(false);
                CallableSystemAction.get(OpenDiscoveryAction.class).setEnabled(false);
 
                /*
                 * Clear the notifications in the notfier component in the lower
                 * right hand corner of the main application window.
                 */
                MessageNotifyUtil.Notify.clear();
 
                /*
                 * Reset the main window title to be just the application name,
                 * instead of [curent case display name] - [application name].
                 */
                mainFrame.setTitle(getNameForTitle());
            });
        }
    }

    public SleuthkitCase getSleuthkitCase() {
        return this.caseDb;
    }

    public Services getServices() {
        return caseServices;
    }

    public CaseType getCaseType() {
        return metadata.getCaseType();
    }

    public String getCreatedDate() {
        return metadata.getCreatedDate();
    }

    public String getName() {
        return metadata.getCaseName();
    }

    public String getDisplayName() {
        return metadata.getCaseDisplayName();
    }

    public String getNumber() {
        return metadata.getCaseNumber();
    }

    public String getExaminer() {
        return metadata.getExaminer();
    }

    public String getExaminerPhone() {
        return metadata.getExaminerPhone();
    }

    public String getExaminerEmail() {
        return metadata.getExaminerEmail();
    }

    public String getCaseNotes() {
        return metadata.getCaseNotes();
    }

    public String getCaseDirectory() {
        return metadata.getCaseDirectory();
    }

    public String getOutputDirectory() {
        String caseDirectory = getCaseDirectory();
        Path hostPath;
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
            hostPath = Paths.get(caseDirectory, NetworkUtils.getLocalHostName());
        } else {
            hostPath = Paths.get(caseDirectory);
        }
        if (!hostPath.toFile().exists()) {
            hostPath.toFile().mkdirs();
        }
        return hostPath.toString();
    }

    private Path getBaseSystemTempPath() {
        return Paths.get(System.getProperty("java.io.tmpdir"), APP_NAME, getName());
    }

    public String getTempDirectory() {
        // NOTE: UserPreferences may also be affected by changes in this method.
        // See JIRA-7505 for more information.
        Path basePath = null;
        // get base temp path for the case based on user preference
        switch (UserMachinePreferences.getTempDirChoice()) {
            case CUSTOM:
                String customDirectory = UserMachinePreferences.getCustomTempDirectory();
                basePath = (StringUtils.isBlank(customDirectory))
                        ? null
                        : Paths.get(customDirectory, APP_NAME, getName());
                break;
            case CASE:
                basePath = Paths.get(getCaseDirectory());
                break;
            case SYSTEM:
            default:
                // at this level, if the case directory is specified for a temp
                // directory, return the system temp directory instead.
                basePath = getBaseSystemTempPath();
                break;
        }
 
        basePath = basePath == null ? getBaseSystemTempPath() : basePath;
 
        // get sub directories based on multi user vs. single user
        Path caseRelPath = (CaseType.MULTI_USER_CASE.equals(getCaseType()))
                ? Paths.get(NetworkUtils.getLocalHostName(), TEMP_FOLDER)
                : Paths.get(TEMP_FOLDER);
 
        File caseTempDir = basePath
                .resolve(caseRelPath)
                .toFile();
 
        // ensure directory exists
        if (!caseTempDir.exists()) {
            caseTempDir.mkdirs();
        }
 
        return caseTempDir.getAbsolutePath();
    }

    public String getCacheDirectory() {
        return getOrCreateSubdirectory(CACHE_FOLDER);
    }

    public String getExportDirectory() {
        return getOrCreateSubdirectory(EXPORT_FOLDER);
    }

    public String getLogDirectoryPath() {
        return getOrCreateSubdirectory(LOG_FOLDER);
    }

    public String getReportDirectory() {
        return getOrCreateSubdirectory(REPORTS_FOLDER);
    }

    public String getConfigDirectory() {
        return getOrCreateSubdirectory(CONFIG_FOLDER);
    }

    public String getModuleDirectory() {
        return getOrCreateSubdirectory(MODULE_FOLDER);
    }

    public String getModuleOutputDirectoryRelativePath() {
        Path path = Paths.get(getModuleDirectory());
        if (getCaseType() == CaseType.MULTI_USER_CASE) {
            return path.subpath(path.getNameCount() - 2, path.getNameCount()).toString();
        } else {
            return path.subpath(path.getNameCount() - 1, path.getNameCount()).toString();
        }
    }

    public List<Content> getDataSources() throws TskCoreException {
        return caseDb.getRootObjects();
    }

    public Set<TimeZone> getTimeZones() {
        Set<TimeZone> timezones = new HashSet<>();
        String query = "SELECT time_zone FROM data_source_info";
        try (SleuthkitCase.CaseDbQuery dbQuery = caseDb.executeQuery(query)) {
            ResultSet timeZoneSet = dbQuery.getResultSet();
            while (timeZoneSet.next()) {
                String timeZone = timeZoneSet.getString("time_zone");
                if (timeZone != null && !timeZone.isEmpty()) {
                    timezones.add(TimeZone.getTimeZone(timeZone));
                }
            }
        } catch (TskCoreException | SQLException ex) {
            logger.log(Level.SEVERE, "Error getting data source time zones", ex); //NON-NLS
        }
        return timezones;
    }

    public String getTextIndexName() {
        return getMetadata().getTextIndexName();
    }

    public boolean hasData() {
        return hasData;
    }

    public boolean hasDataSource() {
        return hasDataSource;
    }

    public void notifyAddingDataSource(UUID eventId) {
        hasDataSource = true;
        hasData = true;
        eventPublisher.publish(new AddingDataSourceEvent(eventId));
    }

    public void notifyFailedAddingDataSource(UUID addingDataSourceEventId) {
        eventPublisher.publish(new AddingDataSourceFailedEvent(addingDataSourceEventId));
    }

    public void notifyDataSourceAdded(Content dataSource, UUID addingDataSourceEventId) {
        eventPublisher.publish(new DataSourceAddedEvent(dataSource, addingDataSourceEventId));
    }

    public void notifyDataSourceNameChanged(Content dataSource, String newName) {
        eventPublisher.publish(new DataSourceNameChangedEvent(dataSource, newName));
    }

    public void notifyContentTagAdded(ContentTag newTag) {
        notifyContentTagAdded(newTag, null);
    }

    public void notifyContentTagAdded(ContentTag newTag, List<ContentTag> deletedTagList) {
        eventPublisher.publish(new ContentTagAddedEvent(newTag, deletedTagList));
    }

    public void notifyContentTagDeleted(ContentTag deletedTag) {
        eventPublisher.publish(new ContentTagDeletedEvent(deletedTag));
    }

    public void notifyTagDefinitionChanged(String changedTagName) {
        //leaving new value of changedTagName as null, because we do not currently support changing the display name of a tag. 
        eventPublisher.publish(new AutopsyEvent(Events.TAG_DEFINITION_CHANGED.toString(), changedTagName, null));
    }

    public void notifyCentralRepoCommentChanged(long contentId, String newComment) {
        try {
            eventPublisher.publish(new CommentChangedEvent(contentId, newComment));
        } catch (NoCurrentCaseException ex) {
            logger.log(Level.WARNING, "Unable to send notifcation regarding comment change due to no current case being open", ex);
        }
    }

    public void notifyBlackBoardArtifactTagAdded(BlackboardArtifactTag newTag) {
        notifyBlackBoardArtifactTagAdded(newTag, null);
    }

    public void notifyBlackBoardArtifactTagAdded(BlackboardArtifactTag newTag, List<BlackboardArtifactTag> removedTagList) {
        eventPublisher.publish(new BlackBoardArtifactTagAddedEvent(newTag, removedTagList));
    }

    public void notifyBlackBoardArtifactTagDeleted(BlackboardArtifactTag deletedTag) {
        eventPublisher.publish(new BlackBoardArtifactTagDeletedEvent(deletedTag));
    }

    public void addReport(String localPath, String srcModuleName, String reportName) throws TskCoreException {
        addReport(localPath, srcModuleName, reportName, null);
    }

    public Report addReport(String localPath, String srcModuleName, String reportName, Content parent) throws TskCoreException {
        String normalizedLocalPath;
        try {
            if (localPath.toLowerCase().contains("http:")) {
                normalizedLocalPath = localPath;
            } else {
                normalizedLocalPath = Paths.get(localPath).normalize().toString();
            }
        } catch (InvalidPathException ex) {
            String errorMsg = "Invalid local path provided: " + localPath; // NON-NLS
            throw new TskCoreException(errorMsg, ex);
        }
        hasData = true;
 
        Report report = this.caseDb.addReport(normalizedLocalPath, srcModuleName, reportName, parent);
        eventPublisher.publish(new ReportAddedEvent(report));
        return report;
    }

    public List<Report> getAllReports() throws TskCoreException {
        return this.caseDb.getAllReports();
    }

    public void deleteReports(Collection<? extends Report> reports) throws TskCoreException {
        for (Report report : reports) {
            this.caseDb.deleteReport(report);
        }
 
        try {
            hasData = dbHasData();
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, "Unable to retrieve the hasData status from the db", ex);
        }
 
        for (Report report : reports) {
            eventPublisher.publish(new AutopsyEvent(Events.REPORT_DELETED.toString(), report, null));
        }
    }

    public CaseMetadata getMetadata() {
        return metadata;
    }

    @Messages({
        "Case.exceptionMessage.metadataUpdateError=Failed to update case metadata"
    })
    void updateCaseDetails(CaseDetails caseDetails) throws CaseActionException {
        CaseDetails oldCaseDetails = metadata.getCaseDetails();
        try {
            metadata.setCaseDetails(caseDetails);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_metadataUpdateError(), ex);
        }
        if (getCaseType() == CaseType.MULTI_USER_CASE && !oldCaseDetails.getCaseDisplayName().equals(caseDetails.getCaseDisplayName())) {
            try {
                CaseNodeData nodeData = CaseNodeData.readCaseNodeData(metadata.getCaseDirectory());
                nodeData.setDisplayName(caseDetails.getCaseDisplayName());
                CaseNodeData.writeCaseNodeData(nodeData);
            } catch (CaseNodeDataException | InterruptedException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotUpdateCaseNodeData(ex.getLocalizedMessage()), ex);
            }
        }
        if (!oldCaseDetails.getCaseNumber().equals(caseDetails.getCaseNumber())) {
            eventPublisher.publish(new AutopsyEvent(Events.NUMBER.toString(), oldCaseDetails.getCaseNumber(), caseDetails.getCaseNumber()));
        }
        if (!oldCaseDetails.getExaminerName().equals(caseDetails.getExaminerName())) {
            eventPublisher.publish(new AutopsyEvent(Events.NUMBER.toString(), oldCaseDetails.getExaminerName(), caseDetails.getExaminerName()));
        }
        if (!oldCaseDetails.getCaseDisplayName().equals(caseDetails.getCaseDisplayName())) {
            eventPublisher.publish(new AutopsyEvent(Events.NAME.toString(), oldCaseDetails.getCaseDisplayName(), caseDetails.getCaseDisplayName()));
        }
        eventPublisher.publish(new AutopsyEvent(Events.CASE_DETAILS.toString(), oldCaseDetails, caseDetails));
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> {
                mainFrame.setTitle(caseDetails.getCaseDisplayName() + " - " + getNameForTitle());
                try {
                    RecentCases.getInstance().updateRecentCase(oldCaseDetails.getCaseDisplayName(), metadata.getFilePath().toString(), caseDetails.getCaseDisplayName(), metadata.getFilePath().toString());
                } catch (Exception ex) {
                    logger.log(Level.SEVERE, "Error updating case name in UI", ex); //NON-NLS
                }
            });
        }
    }

    private Case(CaseType caseType, String caseDir, CaseDetails caseDetails) {
        this(new CaseMetadata(caseType, caseDir, displayNameToUniqueName(caseDetails.getCaseDisplayName()), caseDetails));
    }

    private Case(CaseMetadata caseMetaData) {
        metadata = caseMetaData;
        sleuthkitEventListener = new SleuthkitEventListener();
    }
   
    @Messages({
        "Case.progressIndicatorCancelButton.label=Cancel",
        "Case.progressMessage.preparing=Preparing...",
        "Case.progressMessage.cancelling=Cancelling...",
        "Case.exceptionMessage.cancelled=Cancelled.",
        "# {0} - exception message", "Case.exceptionMessage.execExceptionWrapperMessage={0}"
    })
    private void doOpenCaseAction(String progressIndicatorTitle, CaseAction<ProgressIndicator, Object, Void> caseAction, CaseLockType caseLockType, boolean allowCancellation, Object additionalParams) throws CaseActionException {
        /*
         * Create and start either a GUI progress indicator (with or without a
         * cancel button) or a logging progress indicator.
         */
        CancelButtonListener cancelButtonListener = null;
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            if (allowCancellation) {
                cancelButtonListener = new CancelButtonListener(Bundle.Case_progressMessage_cancelling());
                progressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        progressIndicatorTitle,
                        new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                        Bundle.Case_progressIndicatorCancelButton_label(),
                        cancelButtonListener);
            } else {
                progressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        progressIndicatorTitle);
            }
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());
 
        /*
         * Do the case action in the single thread in the case action executor.
         * If the case is a multi-user case, a case lock is acquired and held
         * until explictly released and an exclusive case resources lock is
         * aquired and held for the duration of the action.
         */
        TaskThreadFactory threadFactory = new TaskThreadFactory(String.format(CASE_ACTION_THREAD_NAME, metadata.getCaseName()));
        caseActionExecutor = Executors.newSingleThreadExecutor(threadFactory);
        Future<Void> future = caseActionExecutor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                caseAction.execute(progressIndicator, additionalParams);
            } else {
                acquireCaseLock(caseLockType);
                try (CoordinationService.Lock resourcesLock = acquireCaseResourcesLock(metadata.getCaseDirectory())) {
                    if (null == resourcesLock) {
                        throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock());
                    }
                    caseAction.execute(progressIndicator, additionalParams);
                } catch (CaseActionException ex) {
                    releaseCaseLock();
                    throw ex;
                }
            }
            return null;
        });
        if (null != cancelButtonListener) {
            cancelButtonListener.setCaseActionFuture(future);
        }
 
        /*
         * Wait for the case action task to finish.
         */
        try {
            future.get();
        } catch (InterruptedException discarded) {
            /*
             * The thread this method is running in has been interrupted.
             */
            if (null != cancelButtonListener) {
                cancelButtonListener.actionPerformed(null);
            } else {
                future.cancel(true);
            }
            ThreadUtils.shutDownTaskExecutor(caseActionExecutor);
        } catch (CancellationException discarded) {
            /*
             * The case action has been cancelled.
             */
            ThreadUtils.shutDownTaskExecutor(caseActionExecutor);
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelled());
        } catch (ExecutionException ex) {
            /*
             * The case action has thrown an exception.
             */
            ThreadUtils.shutDownTaskExecutor(caseActionExecutor);
            throw new CaseActionException(Bundle.Case_exceptionMessage_execExceptionWrapperMessage(ex.getCause().getLocalizedMessage()), ex);
        } finally {
            progressIndicator.finish();
        }
    }

    private Void create(ProgressIndicator progressIndicator, Object additionalParams) throws CaseActionException {
        assert (additionalParams == null);
        try {
            checkForCancellation();
            createCaseDirectoryIfDoesNotExist(progressIndicator);
            checkForCancellation();
            switchLoggingToCaseLogsDirectory(progressIndicator);
            checkForCancellation();
            saveCaseMetadataToFile(progressIndicator);
            checkForCancellation();
            createCaseNodeData(progressIndicator);
            checkForCancellation();
            checkForCancellation();
            createCaseDatabase(progressIndicator);
            checkForCancellation();
            openCaseLevelServices(progressIndicator);
            checkForCancellation();
            openAppServiceCaseResources(progressIndicator, true);
            checkForCancellation();
            openCommunicationChannels(progressIndicator);
            return null;
 
        } catch (CaseActionException ex) {
            /*
             * Cancellation or failure. The sleep is a little hack to clear the
             * interrupted flag for this thread if this is a cancellation
             * scenario, so that the clean up can run to completion in the
             * current thread.
             */
            try {
                Thread.sleep(1);
            } catch (InterruptedException discarded) {
            }
            close(progressIndicator);
            throw ex;
        }
    }

    private Void open(ProgressIndicator progressIndicator, Object additionalParams) throws CaseActionException {
        assert (additionalParams == null);
        try {
            checkForCancellation();
            switchLoggingToCaseLogsDirectory(progressIndicator);
            checkForCancellation();
            updateCaseNodeData(progressIndicator);
            checkForCancellation();
            deleteTempfilesFromCaseDirectory(progressIndicator);
            checkForCancellation();
            openCaseDataBase(progressIndicator);
            checkForCancellation();
            openCaseLevelServices(progressIndicator);
            checkForCancellation();
            openAppServiceCaseResources(progressIndicator, false);
            checkForCancellation();
            openCommunicationChannels(progressIndicator);
            checkForCancellation();
            checkImagePaths();
            checkForCancellation();
            openFileSystemsInBackground();
            return null;
 
        } catch (CaseActionException ex) {
            /*
             * Cancellation or failure. The sleep is a little hack to clear the
             * interrupted flag for this thread if this is a cancellation
             * scenario, so that the clean up can run to completion in the
             * current thread.
             */
            try {
                Thread.sleep(1);
            } catch (InterruptedException discarded) {
            }
            close(progressIndicator);
            throw ex;
        }
    }
    
    @Messages({
        "# {0} - paths",
        "Case_checkImagePaths_noPaths=The following images had no associated paths: {0}",
        "Case_checkImagePaths_exceptionOccurred=An exception occurred while checking if image paths are present"
    })
    private void checkImagePaths() throws CaseActionException {
        // if there is a content provider, images don't necessarily need paths
        if (StringUtils.isNotBlank(this.metadata.getContentProviderName())) {
            return;
        }
        
        // identify images without paths
        try {
            List<Image> noPathImages = new ArrayList<>();
            List<Image> images = this.caseDb.getImages();
            for (Image img: images) {
                if (ArrayUtils.isEmpty(img.getPaths())) {
                    noPathImages.add(img);
                }
            }
            
            if (!noPathImages.isEmpty()) {
                String imageListStr = noPathImages.stream().map(Image::getName).collect(Collectors.joining(", "));
                throw new CaseActionException(Bundle.Case_checkImagePaths_noPaths(imageListStr));
            }
        } catch (TskCoreException ex) {
            throw new CaseActionException(Bundle.Case_checkImagePaths_exceptionOccurred(), ex);
        }
    }

    @Messages({
        "# {0} - case", "Case.openFileSystems.retrievingImages=Retrieving images for case: {0}...",
        "# {0} - image", "Case.openFileSystems.openingImage=Opening all filesystems for image: {0}..."
    })
    private void openFileSystemsInBackground() {
        if (backgroundOpenFileSystemsFuture != null && !backgroundOpenFileSystemsFuture.isDone()) {
            backgroundOpenFileSystemsFuture.cancel(true);
        }
 
        BackgroundOpenFileSystemsTask backgroundTask = new BackgroundOpenFileSystemsTask(this.caseDb, new LoggingProgressIndicator());
        backgroundOpenFileSystemsFuture = openFileSystemsExecutor.submit(backgroundTask);
    }

    private static class BackgroundOpenFileSystemsTask implements Runnable {
 
        private final SleuthkitCase tskCase;
        private final String caseName;
        private final long MAX_IMAGE_THRESHOLD = 100;
        private final ProgressIndicator progressIndicator;

        BackgroundOpenFileSystemsTask(SleuthkitCase tskCase, ProgressIndicator progressIndicator) {
            this.tskCase = tskCase;
            this.progressIndicator = progressIndicator;
            caseName = (this.tskCase != null) ? this.tskCase.getDatabaseName() : "";
        }

        private void checkIfCancelled() throws InterruptedException {
            if (Thread.interrupted()) {
                throw new InterruptedException();
            }
        }

        private List<Image> getImages() {
            progressIndicator.progress(Bundle.Case_openFileSystems_retrievingImages(caseName));
            try {
                return this.tskCase.getImages();
            } catch (TskCoreException ex) {
                logger.log(
                        Level.SEVERE,
                        String.format("Could not obtain images while opening case: %s.", caseName),
                        ex);
 
                return null;
            }
        }

        private void openFileSystems(List<Image> images) throws TskCoreException, InterruptedException {
            byte[] tempBuff = new byte[512];
 
            for (Image image : images) {
                String imageStr = image.getName();
 
                progressIndicator.progress(Bundle.Case_openFileSystems_openingImage(imageStr));
 
                Collection<FileSystem> fileSystems = this.tskCase.getImageFileSystems(image);
                checkIfCancelled();
                for (FileSystem fileSystem : fileSystems) {
                    fileSystem.read(tempBuff, 0, 512);
                    checkIfCancelled();
                }
 
            }
        }
 
        @Override
        public void run() {
            try {
                checkIfCancelled();
                List<Image> images = getImages();
                if (images == null) {
                    return;
                }
 
                if (images.size() > MAX_IMAGE_THRESHOLD) {
                    // If we have a large number of images, don't try to preload anything
                    logger.log(
                            Level.INFO,
                            String.format("Skipping background load of file systems due to large number of images in case (%d)", images.size()));
                    return;
                }
 
                checkIfCancelled();
                openFileSystems(images);
            } catch (InterruptedException ex) {
                logger.log(
                        Level.INFO,
                        String.format("Background operation opening all file systems in %s has been cancelled.", caseName));
            } catch (Exception ex) {
                // Exception firewall
                logger.log(Level.WARNING, "Error while opening file systems in background", ex);
            }
        }
 
    }

    @Messages({
        "Case.progressMessage.deletingDataSource=Removing the data source from the case...",
        "Case.exceptionMessage.dataSourceNotFound=The data source was not found.",
        "Case.exceptionMessage.errorDeletingDataSourceFromCaseDb=An error occurred while removing the data source from the case database.",
        "Case.exceptionMessage.errorDeletingDataSourceFromTextIndex=An error occurred while removing the data source from the text index.",})
    Void deleteDataSource(ProgressIndicator progressIndicator, Object additionalParams) throws CaseActionException {
        assert (additionalParams instanceof Long);
        open(progressIndicator, null);
        try {
            progressIndicator.progress(Bundle.Case_progressMessage_deletingDataSource());
            Long dataSourceObjectID = (Long) additionalParams;
            try {
                DataSource dataSource = this.caseDb.getDataSource(dataSourceObjectID);
                if (dataSource == null) {
                    throw new CaseActionException(Bundle.Case_exceptionMessage_dataSourceNotFound());
                }
                SleuthkitCaseAdminUtil.deleteDataSource(this.caseDb, dataSourceObjectID);
            } catch (TskDataException | TskCoreException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_errorDeletingDataSourceFromCaseDb(), ex);
            }
            try {
                this.caseServices.getKeywordSearchService().deleteDataSource(dataSourceObjectID);
            } catch (KeywordSearchServiceException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_errorDeletingDataSourceFromTextIndex(), ex);
            }
            eventPublisher.publish(new DataSourceDeletedEvent(dataSourceObjectID));
            return null;
        } finally {
            close(progressIndicator);
            releaseCaseLock();
        }
    }

    public SleuthkitCase createPortableCase(String caseName, File portableCaseFolder) throws TskCoreException {
 
        if (portableCaseFolder.exists()) {
            throw new TskCoreException("Portable case folder " + portableCaseFolder.toString() + " already exists");
        }
        if (!portableCaseFolder.mkdirs()) {
            throw new TskCoreException("Error creating portable case folder " + portableCaseFolder.toString());
        }
 
        CaseDetails details = new CaseDetails(caseName, getNumber(), getExaminer(),
                getExaminerPhone(), getExaminerEmail(), getCaseNotes());
        try {
            CaseMetadata portableCaseMetadata = new CaseMetadata(Case.CaseType.SINGLE_USER_CASE, portableCaseFolder.toString(),
                    caseName, details, metadata);
            portableCaseMetadata.setCaseDatabaseName(SINGLE_USER_CASE_DB_NAME);
        } catch (CaseMetadataException ex) {
            throw new TskCoreException("Error creating case metadata", ex);
        }
 
        // Create the Sleuthkit case
        SleuthkitCase portableSleuthkitCase;
        String dbFilePath = Paths.get(portableCaseFolder.toString(), SINGLE_USER_CASE_DB_NAME).toString();
        portableSleuthkitCase = SleuthkitCase.newCase(dbFilePath);
 
        return portableSleuthkitCase;
    }

    private static void checkForCancellation() throws CaseActionCancelledException {
        if (Thread.currentThread().isInterrupted()) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelled());
        }
    }

    @Messages({
        "Case.progressMessage.creatingCaseDirectory=Creating case directory..."
    })
    private void createCaseDirectoryIfDoesNotExist(ProgressIndicator progressIndicator) throws CaseActionException {
        /*
         * TODO (JIRA-2180): Always create the case directory as part of the
         * case creation process.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDirectory());
        if (new File(metadata.getCaseDirectory()).exists() == false) {
            progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDirectory());
            Case.createCaseDirectory(metadata.getCaseDirectory(), metadata.getCaseType());
        }
    }

    @Messages({
        "Case.progressMessage.switchingLogDirectory=Switching log directory..."
    })
    private void switchLoggingToCaseLogsDirectory(ProgressIndicator progressIndicator) {
        progressIndicator.progress(Bundle.Case_progressMessage_switchingLogDirectory());
        Logger.setLogDirectory(getLogDirectoryPath());
    }

    @Messages({
        "Case.progressMessage.savingCaseMetadata=Saving case metadata to file...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotSaveCaseMetadata=Failed to save case metadata:\n{0}."
    })
    private void saveCaseMetadataToFile(ProgressIndicator progressIndicator) throws CaseActionException {
        progressIndicator.progress(Bundle.Case_progressMessage_savingCaseMetadata());
        try {
            this.metadata.writeToFile();
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotSaveCaseMetadata(ex.getLocalizedMessage()), ex);
        }
    }

    @Messages({
        "Case.progressMessage.creatingCaseNodeData=Creating coordination service node data...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotCreateCaseNodeData=Failed to create coordination service node data:\n{0}."
    })
    private void createCaseNodeData(ProgressIndicator progressIndicator) throws CaseActionException {
        if (getCaseType() == CaseType.MULTI_USER_CASE) {
            progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseNodeData());
            try {
                CaseNodeData.createCaseNodeData(metadata);
            } catch (CaseNodeDataException | InterruptedException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateCaseNodeData(ex.getLocalizedMessage()), ex);
            }
        }
    }

    @Messages({
        "Case.progressMessage.updatingCaseNodeData=Updating coordination service node data...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotUpdateCaseNodeData=Failed to update coordination service node data:\n{0}."
    })
    private void updateCaseNodeData(ProgressIndicator progressIndicator) throws CaseActionException {
        if (getCaseType() == CaseType.MULTI_USER_CASE) {
            progressIndicator.progress(Bundle.Case_progressMessage_updatingCaseNodeData());
            try {
                CaseNodeData nodeData = CaseNodeData.readCaseNodeData(metadata.getCaseDirectory());
                nodeData.setLastAccessDate(new Date());
                CaseNodeData.writeCaseNodeData(nodeData);
            } catch (CaseNodeDataException | InterruptedException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotUpdateCaseNodeData(ex.getLocalizedMessage()), ex);
            }
        }
    }

    @Messages({
        "Case.progressMessage.clearingTempDirectory=Clearing case temp directory..."
    })
    private void deleteTempfilesFromCaseDirectory(ProgressIndicator progressIndicator) {
        /*
         * Clear the temp subdirectory of the case directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_clearingTempDirectory());
        FileUtil.deleteDir(new File(this.getTempDirectory()));
    }

    @Messages({
        "Case.progressMessage.creatingCaseDatabase=Creating case database...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotGetDbServerConnectionInfo=Failed to get case database server conneciton info:\n{0}.",
        "# {0} - exception message", "Case.exceptionMessage.couldNotCreateCaseDatabase=Failed to create case database:\n{0}.",
        "# {0} - exception message", "Case.exceptionMessage.couldNotSaveDbNameToMetadataFile=Failed to save case database name to case metadata file:\n{0}."
    })
    private void createCaseDatabase(ProgressIndicator progressIndicator) throws CaseActionException {
        progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDatabase());
        try {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                /*
                 * For single-user cases, the case database is a SQLite database
                 * with a standard name, physically located in the case
                 * directory.
                 */
                caseDb = SleuthkitCase.newCase(Paths.get(metadata.getCaseDirectory(), SINGLE_USER_CASE_DB_NAME).toString(), (ContentStreamProvider) null, APP_NAME);
                metadata.setCaseDatabaseName(SINGLE_USER_CASE_DB_NAME);
            } else {
                /*
                 * For multi-user cases, the case database is a PostgreSQL
                 * database with a name derived from the case display name,
                 * physically located on the PostgreSQL database server.
                 */
                caseDb = SleuthkitCase.newCase(metadata.getCaseDisplayName(), UserPreferences.getDatabaseConnectionInfo(), metadata.getCaseDirectory());
                metadata.setCaseDatabaseName(caseDb.getDatabaseName());
            }
        } catch (TskCoreException ex) {
            throwIfConcurrentDbAccessException(ex);
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateCaseDatabase(ex.getLocalizedMessage()), ex);
        } catch (UserPreferencesException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotGetDbServerConnectionInfo(ex.getLocalizedMessage()), ex);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotSaveDbNameToMetadataFile(ex.getLocalizedMessage()), ex);
        }
    }

    @Messages({
        "Case.progressMessage.openingCaseDatabase=Opening case database...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotOpenCaseDatabase=Failed to open case database:\n{0}.",
        "# {0} - exception message", "Case.exceptionMessage.unsupportedSchemaVersionMessage=Unsupported case database schema version:\n{0}.",
        "Case.exceptionMessage.contentProviderCouldNotBeFound=Content provider was specified for the case but could not be loaded.",
        "Case.open.exception.multiUserCaseNotEnabled=Cannot open a multi-user case if multi-user cases are not enabled. See Tools, Options, Multi-User."
    })
    private void openCaseDataBase(ProgressIndicator progressIndicator) throws CaseActionException {
        progressIndicator.progress(Bundle.Case_progressMessage_openingCaseDatabase());
        try {
            String databaseName = metadata.getCaseDatabaseName();
 
            ContentStreamProvider contentProvider = loadContentProvider(metadata.getContentProviderName());
            if (StringUtils.isNotBlank(metadata.getContentProviderName()) && contentProvider == null) {
                if (metadata.getContentProviderName().trim().toUpperCase().startsWith(CT_PROVIDER_PREFIX.toUpperCase())) {
                    new CTIntegrationMissingDialog(WindowManager.getDefault().getMainWindow(), true).showDialog(null);
                }
                throw new CaseActionException(Bundle.Case_exceptionMessage_contentProviderCouldNotBeFound());
            }
 
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                caseDb = SleuthkitCase.openCase(metadata.getCaseDatabasePath(), contentProvider, APP_NAME);
            } else if (UserPreferences.getIsMultiUserModeEnabled()) {
                caseDb = SleuthkitCase.openCase(databaseName, UserPreferences.getDatabaseConnectionInfo(), metadata.getCaseDirectory(), contentProvider);
            } else {
                throw new CaseActionException(Bundle.Case_open_exception_multiUserCaseNotEnabled());
            }
            updateDataParameters();
        } catch (TskUnsupportedSchemaVersionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_unsupportedSchemaVersionMessage(ex.getLocalizedMessage()), ex);
        } catch (UserPreferencesException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotGetDbServerConnectionInfo(ex.getLocalizedMessage()), ex);
        } catch (TskCoreException ex) {
            throwIfConcurrentDbAccessException(ex);
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotOpenCaseDatabase(ex.getLocalizedMessage()), ex);    
        }
    }
    
    
    @Messages({
        "# {0} - appplicationName",
        "Case_throwIfConcurrentDbAccessException_fileLock_concurrentAccessException=The case is open in {0}. Please close it before attempting to open it in Autopsy.",
        "Case_throwIfConcurrentDbAccessException_fileLock_concurrentAccessException_defaultApp=another application"
    })
    private void throwIfConcurrentDbAccessException(Exception ex) throws CaseActionException {
        ConcurrentDbAccessException concurrentEx = null;
        Throwable curEx = ex;
        // max depth search for a concurrent db access exception will be 10
        for (int i = 0; i < 10; i++) {
            if (curEx == null) {
                break;
            } else if (curEx instanceof ConcurrentDbAccessException foundEx) {
                concurrentEx = foundEx;
                break;
            } else {
                curEx = curEx.getCause();    
            }
        }
        
        if (concurrentEx != null) {
            throw new CaseActionException(Bundle.Case_throwIfConcurrentDbAccessException_fileLock_concurrentAccessException(
                    StringUtils.defaultIfBlank(concurrentEx.getConflictingApplicationName(),
                            Bundle.Case_throwIfConcurrentDbAccessException_fileLock_concurrentAccessException_defaultApp())
            ), concurrentEx);
        }
    }
    
     
    private static ContentStreamProvider loadContentProvider(String providerName) {
        Collection<? extends AutopsyContentProvider> customContentProviders = Lookup.getDefault().lookupAll(AutopsyContentProvider.class);
        if (customContentProviders != null) {
            for (AutopsyContentProvider customProvider : customContentProviders) {
                // ensure the provider matches the name
                if (customProvider == null || !StringUtils.equalsIgnoreCase(providerName, customProvider.getName())) {
                    continue;
                }
                
                ContentStreamProvider contentProvider = customProvider.load();
                if (contentProvider != null) {
                    return contentProvider;
                }
            }
        }
        
        return null;
    }
 

    @Messages({
        "Case.progressMessage.openingCaseLevelServices=Opening case-level services...",})
    private void openCaseLevelServices(ProgressIndicator progressIndicator) {
        progressIndicator.progress(Bundle.Case_progressMessage_openingCaseLevelServices());
        this.caseServices = new Services(caseDb);
        /*
         * RC Note: JM put this initialization here. I'm not sure why. However,
         * my attempt to put it in the openCaseDatabase method seems to lead to
         * intermittent unchecked exceptions concerning a missing subscriber.
         */
        caseDb.registerForEvents(sleuthkitEventListener);
    }

    @NbBundle.Messages({
        "Case.progressMessage.openingApplicationServiceResources=Opening application service case resources...",
        "# {0} - service name", "Case.serviceOpenCaseResourcesProgressIndicator.title={0} Opening Case Resources",
        "# {0} - service name", "Case.serviceOpenCaseResourcesProgressIndicator.cancellingMessage=Cancelling opening case resources by {0}...",
        "# {0} - service name", "Case.servicesException.notificationTitle={0} Error"
    })
    private void openAppServiceCaseResources(ProgressIndicator progressIndicator, boolean isNewCase) throws CaseActionException {
        /*
         * Each service gets its own independently cancellable/interruptible
         * task, running in a named thread managed by an executor service, with
         * its own progress indicator. This allows for cancellation of the
         * opening of case resources for individual services. It also makes it
         * possible to ensure that each service task completes before the next
         * one starts by awaiting termination of the executor service.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_openingApplicationServiceResources());
 
        for (AutopsyService service : Lookup.getDefault().lookupAll(AutopsyService.class
        )) {
            /*
             * Create a progress indicator for the task and start the task. If
             * running with a GUI, the progress indicator will be a dialog box
             * with a Cancel button.
             */
            CancelButtonListener cancelButtonListener = null;
            ProgressIndicator appServiceProgressIndicator;
            if (RuntimeProperties.runningWithGUI()) {
                cancelButtonListener = new CancelButtonListener(Bundle.Case_serviceOpenCaseResourcesProgressIndicator_cancellingMessage(service.getServiceName()));
                appServiceProgressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        Bundle.Case_serviceOpenCaseResourcesProgressIndicator_title(service.getServiceName()),
                        new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                        Bundle.Case_progressIndicatorCancelButton_label(),
                        cancelButtonListener);
            } else {
                appServiceProgressIndicator = new LoggingProgressIndicator();
            }
            appServiceProgressIndicator.start(Bundle.Case_progressMessage_preparing());
            AutopsyService.CaseContext context = new AutopsyService.CaseContext(this, appServiceProgressIndicator, isNewCase);
            String threadNameSuffix = service.getServiceName().replaceAll("[ ]", "-"); //NON-NLS
            threadNameSuffix = threadNameSuffix.toLowerCase();
            TaskThreadFactory threadFactory = new TaskThreadFactory(String.format(CASE_RESOURCES_THREAD_NAME, threadNameSuffix));
            ExecutorService executor = Executors.newSingleThreadExecutor(threadFactory);
            Future<Void> future = executor.submit(() -> {
                service.openCaseResources(context);
                return null;
            });
            if (null != cancelButtonListener) {
                cancelButtonListener.setCaseContext(context);
                cancelButtonListener.setCaseActionFuture(future);
            }
 
            /*
             * Wait for the task to either be completed or
             * cancelled/interrupted, or for the opening of the case to be
             * cancelled.
             */
            try {
                future.get();
            } catch (InterruptedException discarded) {
                /*
                 * The parent create/open case task has been cancelled.
                 */
                Case.logger.log(Level.WARNING, String.format("Opening of %s (%s) in %s cancelled during opening of case resources by %s", getDisplayName(), getName(), getCaseDirectory(), service.getServiceName()));
                future.cancel(true);
            } catch (CancellationException discarded) {
                /*
                 * The opening of case resources by the application service has
                 * been cancelled, so the executor service has thrown. Note that
                 * there is no guarantee the task itself has responded to the
                 * cancellation request yet.
                 */
                Case.logger.log(Level.WARNING, String.format("Opening of case resources by %s for %s (%s) in %s cancelled", service.getServiceName(), getDisplayName(), getName(), getCaseDirectory(), service.getServiceName()));
            } catch (ExecutionException ex) {
                /*
                 * An exception was thrown while executing the task. The
                 * case-specific application service resources are not
                 * essential. Log an error and notify the user if running the
                 * desktop GUI, but do not throw.
                 */
                Case.logger.log(Level.SEVERE, String.format("%s failed to open case resources for %s", service.getServiceName(), this.getDisplayName()), ex);
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> {
                        MessageNotifyUtil.Notify.error(Bundle.Case_servicesException_notificationTitle(service.getServiceName()), ex.getLocalizedMessage());
                    });
                }
            } finally {
                /*
                 * Shut down the executor service and wait for it to finish.
                 * This ensures that the task has finished. Without this, it
                 * would be possible to start the next task before the current
                 * task responded to a cancellation request.
                 */
                ThreadUtils.shutDownTaskExecutor(executor);
                appServiceProgressIndicator.finish();
            }
            checkForCancellation();
        }
    }

    @Messages({
        "Case.progressMessage.settingUpNetworkCommunications=Setting up network communications...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotOpenRemoteEventChannel=Failed to open remote events channel:\n{0}.",
        "# {0} - exception message", "Case.exceptionMessage.couldNotCreatCollaborationMonitor=Failed to create collaboration monitor:\n{0}."
    })
    private void openCommunicationChannels(ProgressIndicator progressIndicator) throws CaseActionException {
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
            progressIndicator.progress(Bundle.Case_progressMessage_settingUpNetworkCommunications());
            try {
                eventPublisher.openRemoteEventChannel(String.format(EVENT_CHANNEL_NAME, metadata.getCaseName()));
                checkForCancellation();
                collaborationMonitor = new CollaborationMonitor(metadata.getCaseName());
            } catch (AutopsyEventException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotOpenRemoteEventChannel(ex.getLocalizedMessage()), ex);
            } catch (CollaborationMonitor.CollaborationMonitorException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreatCollaborationMonitor(ex.getLocalizedMessage()), ex);
            }
        }
    }

    private void doCloseCaseAction() throws CaseActionException {
        /*
         * Set up either a GUI progress indicator without a Cancel button or a
         * logging progress indicator.
         */
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator = new ModalDialogProgressIndicator(
                    mainFrame,
                    Bundle.Case_progressIndicatorTitle_closingCase());
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());
 
        /*
         * Closing a case is always done in the same non-UI thread that
         * opened/created the case. If the case is a multi-user case, this
         * ensures that case lock that is held as long as the case is open is
         * released in the same thread in which it was acquired, as is required
         * by the coordination service.
         */
        Future<Void> future = caseActionExecutor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                close(progressIndicator);
            } else {
                /*
                 * Acquire an exclusive case resources lock to ensure only one
                 * node at a time can create/open/upgrade/close the case
                 * resources.
                 */
                progressIndicator.progress(Bundle.Case_progressMessage_preparing());
                try (CoordinationService.Lock resourcesLock = acquireCaseResourcesLock(metadata.getCaseDirectory())) {
                    if (null == resourcesLock) {
                        throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock());
                    }
                    close(progressIndicator);
                } finally {
                    /*
                     * Always release the case directory lock that was acquired
                     * when the case was opened.
                     */
                    releaseCaseLock();
                }
            }
            return null;
        });
 
        try {
            future.get();
        } catch (InterruptedException | CancellationException unused) {
            /*
             * The wait has been interrupted by interrupting the thread running
             * this method. Not allowing cancellation of case closing, so ignore
             * the interrupt. Likewise, cancellation of the case closing task is
             * not supported.
             */
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_execExceptionWrapperMessage(ex.getCause().getMessage()), ex);
        } finally {
            ThreadUtils.shutDownTaskExecutor(caseActionExecutor);
            progressIndicator.finish();
        }
    }

    @Messages({
        "Case.progressMessage.shuttingDownNetworkCommunications=Shutting down network communications...",
        "Case.progressMessage.closingApplicationServiceResources=Closing case-specific application service resources...",
        "Case.progressMessage.closingCaseDatabase=Closing case database..."
    })
    private void close(ProgressIndicator progressIndicator) {
        IngestManager.getInstance().cancelAllIngestJobs(IngestJob.CancellationReason.CASE_CLOSED);
 
        /*
         * Stop sending/receiving case events to and from other nodes if this is
         * a multi-user case.
         */
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
            progressIndicator.progress(Bundle.Case_progressMessage_shuttingDownNetworkCommunications());
            if (null != collaborationMonitor) {
                collaborationMonitor.shutdown();
            }
            eventPublisher.closeRemoteEventChannel();
        }
 
        /*
         * Allow all registered application services providers to close
         * resources related to the case.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_closingApplicationServiceResources());
        closeAppServiceCaseResources();
 
        /*
         * Close the case database.
         */
        if (null != caseDb) {
            progressIndicator.progress(Bundle.Case_progressMessage_closingCaseDatabase());
            caseDb.unregisterForEvents(sleuthkitEventListener);
            caseDb.close();
        }

        deleteTempfilesFromCaseDirectory(progressIndicator);
 
        /*
         * Switch the log directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_switchingLogDirectory());
        Logger.setLogDirectory(PlatformUtil.getLogDirectory());
    }

    @Messages({
        "# {0} - serviceName", "Case.serviceCloseResourcesProgressIndicator.title={0} Closing Case Resources",
        "# {0} - service name", "# {1} - exception message", "Case.servicesException.serviceResourcesCloseError=Could not close case resources for {0} service: {1}"
    })
    private void closeAppServiceCaseResources() {
        /*
         * Each service gets its own independently cancellable task, and thus
         * its own task progress indicator.
         */
        for (AutopsyService service : Lookup.getDefault().lookupAll(AutopsyService.class
        )) {
            ProgressIndicator progressIndicator;
            if (RuntimeProperties.runningWithGUI()) {
                progressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        Bundle.Case_serviceCloseResourcesProgressIndicator_title(service.getServiceName()));
            } else {
                progressIndicator = new LoggingProgressIndicator();
            }
            progressIndicator.start(Bundle.Case_progressMessage_preparing());
            AutopsyService.CaseContext context = new AutopsyService.CaseContext(this, progressIndicator);
            String threadNameSuffix = service.getServiceName().replaceAll("[ ]", "-"); //NON-NLS
            threadNameSuffix = threadNameSuffix.toLowerCase();
            TaskThreadFactory threadFactory = new TaskThreadFactory(String.format(CASE_RESOURCES_THREAD_NAME, threadNameSuffix));
            ExecutorService executor = Executors.newSingleThreadExecutor(threadFactory);
            Future<Void> future = executor.submit(() -> {
                service.closeCaseResources(context);
                return null;
            });
            try {
                future.get();
            } catch (InterruptedException ex) {
                Case.logger.log(Level.SEVERE, String.format("Unexpected interrupt while waiting on %s service to close case resources", service.getServiceName()), ex);
            } catch (CancellationException ex) {
                Case.logger.log(Level.SEVERE, String.format("Unexpected cancellation while waiting on %s service to close case resources", service.getServiceName()), ex);
            } catch (ExecutionException ex) {
                Case.logger.log(Level.SEVERE, String.format("%s service failed to open case resources", service.getServiceName()), ex);
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> MessageNotifyUtil.Notify.error(
                            Bundle.Case_servicesException_notificationTitle(service.getServiceName()),
                            Bundle.Case_servicesException_serviceResourcesCloseError(service.getServiceName(), ex.getLocalizedMessage())));
                }
            } finally {
                ThreadUtils.shutDownTaskExecutor(executor);
                progressIndicator.finish();
            }
        }
    }

    @Messages({
        "Case.lockingException.couldNotAcquireSharedLock=Failed to get a shared lock on the case.",
        "Case.lockingException.couldNotAcquireExclusiveLock=Failed to get an exclusive lock on the case."
    })
    private void acquireCaseLock(CaseLockType lockType) throws CaseActionException {
        String caseDir = metadata.getCaseDirectory();
        try {
            CoordinationService coordinationService = CoordinationService.getInstance();
            caseLock = lockType == CaseLockType.SHARED
                    ? coordinationService.tryGetSharedLock(CategoryNode.CASES, caseDir, CASE_LOCK_TIMEOUT_MINS, TimeUnit.MINUTES)
                    : coordinationService.tryGetExclusiveLock(CategoryNode.CASES, caseDir, CASE_LOCK_TIMEOUT_MINS, TimeUnit.MINUTES);
            if (caseLock == null) {
                if (lockType == CaseLockType.SHARED) {
                    throw new CaseActionException(Bundle.Case_lockingException_couldNotAcquireSharedLock());
                } else {
                    throw new CaseActionException(Bundle.Case_lockingException_couldNotAcquireExclusiveLock());
                }
            }
        } catch (InterruptedException | CoordinationServiceException ex) {
            if (lockType == CaseLockType.SHARED) {
                throw new CaseActionException(Bundle.Case_lockingException_couldNotAcquireSharedLock(), ex);
            } else {
                throw new CaseActionException(Bundle.Case_lockingException_couldNotAcquireExclusiveLock(), ex);
            }
        }
    }

    private void releaseCaseLock() {
        if (caseLock != null) {
            try {
                caseLock.release();
                caseLock = null;
            } catch (CoordinationService.CoordinationServiceException ex) {
                logger.log(Level.SEVERE, String.format("Failed to release shared case directory lock for %s", getMetadata().getCaseDirectory()), ex);
            }
        }
    }

    private String getOrCreateSubdirectory(String subDirectoryName) {
        File subDirectory = Paths.get(getOutputDirectory(), subDirectoryName).toFile();
        if (!subDirectory.exists()) {
            subDirectory.mkdirs();
        }
        return subDirectory.toString();
 
    }

    @Messages({
        "Case.exceptionMessage.errorsDeletingCase=Errors occured while deleting the case. See the application log for details."
    })
    private static void deleteSingleUserCase(CaseMetadata metadata, ProgressIndicator progressIndicator) throws CaseActionException {
        boolean errorsOccurred = false;
        try {
            deleteTextIndex(metadata, progressIndicator);
        } catch (KeywordSearchServiceException ex) {
            errorsOccurred = true;
            logger.log(Level.WARNING, String.format("Failed to delete text index for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
        }
 
        try {
            deleteCaseDirectory(metadata, progressIndicator);
        } catch (CaseActionException ex) {
            errorsOccurred = true;
            logger.log(Level.WARNING, String.format("Failed to delete case directory for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
        }
 
        deleteFromRecentCases(metadata, progressIndicator);
 
        if (errorsOccurred) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_errorsDeletingCase());
        }
    }

    @Messages({
        "Case.progressMessage.connectingToCoordSvc=Connecting to coordination service...",
        "# {0} - exception message", "Case.exceptionMessage.failedToConnectToCoordSvc=Failed to connect to coordination service:\n{0}.",
        "Case.exceptionMessage.cannotGetLockToDeleteCase=Cannot delete case because it is open for another user or host.",
        "# {0} - exception message", "Case.exceptionMessage.failedToLockCaseForDeletion=Failed to exclusively lock case for deletion:\n{0}.",
        "Case.progressMessage.fetchingCoordSvcNodeData=Fetching coordination service node data for the case...",
        "# {0} - exception message", "Case.exceptionMessage.failedToFetchCoordSvcNodeData=Failed to fetch coordination service node data:\n{0}.",
        "Case.progressMessage.deletingResourcesCoordSvcNode=Deleting case resources coordination service node...",
        "Case.progressMessage.deletingCaseDirCoordSvcNode=Deleting case directory coordination service node..."
    })
    private static void deleteMultiUserCase(CaseMetadata metadata, ProgressIndicator progressIndicator) throws CaseActionException, InterruptedException {
        progressIndicator.progress(Bundle.Case_progressMessage_connectingToCoordSvc());
        CoordinationService coordinationService;
        try {
            coordinationService = CoordinationService.getInstance();
        } catch (CoordinationServiceException ex) {
            logger.log(Level.SEVERE, String.format("Failed to connect to coordination service when attempting to delete %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
            throw new CaseActionException(Bundle.Case_exceptionMessage_failedToConnectToCoordSvc(ex.getLocalizedMessage()));
        }
 
        CaseNodeData caseNodeData;
        boolean errorsOccurred = false;
        try (CoordinationService.Lock dirLock = coordinationService.tryGetExclusiveLock(CategoryNode.CASES, metadata.getCaseDirectory())) {
            if (dirLock == null) {
                logger.log(Level.INFO, String.format("Could not delete %s (%s) in %s because a case directory lock was held by another host", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory())); //NON-NLS
                throw new CaseActionException(Bundle.Case_exceptionMessage_cannotGetLockToDeleteCase());
            }
 
            progressIndicator.progress(Bundle.Case_progressMessage_fetchingCoordSvcNodeData());
            try {
                caseNodeData = CaseNodeData.readCaseNodeData(metadata.getCaseDirectory());
            } catch (CaseNodeDataException | InterruptedException ex) {
                logger.log(Level.SEVERE, String.format("Failed to get coordination service node data %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
                throw new CaseActionException(Bundle.Case_exceptionMessage_failedToFetchCoordSvcNodeData(ex.getLocalizedMessage()));
            }
 
            errorsOccurred = deleteMultiUserCase(caseNodeData, metadata, progressIndicator, logger);
 
            progressIndicator.progress(Bundle.Case_progressMessage_deletingResourcesCoordSvcNode());
            try {
                String resourcesLockNodePath = CoordinationServiceUtils.getCaseResourcesNodePath(caseNodeData.getDirectory());
                coordinationService.deleteNode(CategoryNode.CASES, resourcesLockNodePath);
            } catch (CoordinationServiceException ex) {
                if (!isNoNodeException(ex)) {
                    errorsOccurred = true;
                    logger.log(Level.WARNING, String.format("Error deleting the case resources coordination service node for the case at %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
                }
            } catch (InterruptedException ex) {
                logger.log(Level.WARNING, String.format("Error deleting the case resources coordination service node for the case at %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
            }
 
        } catch (CoordinationServiceException ex) {
            logger.log(Level.SEVERE, String.format("Error exclusively locking the case directory for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
            throw new CaseActionException(Bundle.Case_exceptionMessage_failedToLockCaseForDeletion(ex.getLocalizedMessage()));
        }
 
        if (!errorsOccurred) {
            progressIndicator.progress(Bundle.Case_progressMessage_deletingCaseDirCoordSvcNode());
            try {
                String casDirNodePath = CoordinationServiceUtils.getCaseDirectoryNodePath(caseNodeData.getDirectory());
                coordinationService.deleteNode(CategoryNode.CASES, casDirNodePath);
            } catch (CoordinationServiceException | InterruptedException ex) {
                logger.log(Level.SEVERE, String.format("Error deleting the case directory lock node for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
                errorsOccurred = true;
            }
        }
 
        if (errorsOccurred) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_errorsDeletingCase());
        }
    }

    @Beta
    public static boolean deleteMultiUserCase(CaseNodeData caseNodeData, CaseMetadata metadata, ProgressIndicator progressIndicator, Logger logger) throws InterruptedException {
        boolean errorsOccurred = false;
        try {
            deleteMultiUserCaseDatabase(caseNodeData, metadata, progressIndicator, logger);
            deleteMultiUserCaseTextIndex(caseNodeData, metadata, progressIndicator, logger);
            deleteMultiUserCaseDirectory(caseNodeData, metadata, progressIndicator, logger);
            deleteFromRecentCases(metadata, progressIndicator);
        } catch (UserPreferencesException | ClassNotFoundException | SQLException ex) {
            errorsOccurred = true;
            logger.log(Level.WARNING, String.format("Failed to delete the case database for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
        } catch (KeywordSearchServiceException ex) {
            errorsOccurred = true;
            logger.log(Level.WARNING, String.format("Failed to delete the text index for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
        } catch (CaseActionException ex) {
            errorsOccurred = true;
            logger.log(Level.WARNING, String.format("Failed to delete the case directory for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex); //NON-NLS
        }
        return errorsOccurred;
    }

    @Messages({
        "Case.progressMessage.deletingCaseDatabase=Deleting case database..."
    })
    private static void deleteMultiUserCaseDatabase(CaseNodeData caseNodeData, CaseMetadata metadata, ProgressIndicator progressIndicator, Logger logger) throws UserPreferencesException, ClassNotFoundException, SQLException, InterruptedException {
        if (!caseNodeData.isDeletedFlagSet(CaseNodeData.DeletedFlags.CASE_DB)) {
            progressIndicator.progress(Bundle.Case_progressMessage_deletingCaseDatabase());
            logger.log(Level.INFO, String.format("Deleting case database for %s (%s) in %s", caseNodeData.getDisplayName(), caseNodeData.getName(), caseNodeData.getDirectory())); //NON-NLS
            CaseDbConnectionInfo info = UserPreferences.getDatabaseConnectionInfo();
            String url = "jdbc:postgresql://" + info.getHost() + ":" + info.getPort() + "/postgres"; //NON-NLS
            Class.forName("org.postgresql.Driver"); //NON-NLS
            try (Connection connection = DriverManager.getConnection(url, info.getUserName(), info.getPassword()); Statement statement = connection.createStatement()) {
                String dbExistsQuery = "SELECT 1 from pg_database WHERE datname = '" + metadata.getCaseDatabaseName() + "'"; //NON-NLS
                try (ResultSet queryResult = statement.executeQuery(dbExistsQuery)) {
                    if (queryResult.next()) {
                        String deleteCommand = "DROP DATABASE \"" + metadata.getCaseDatabaseName() + "\""; //NON-NLS
                        statement.execute(deleteCommand);
                    }
                }
            }
            setDeletedItemFlag(caseNodeData, CaseNodeData.DeletedFlags.CASE_DB);
        }
    }

    private static void deleteMultiUserCaseTextIndex(CaseNodeData caseNodeData, CaseMetadata metadata, ProgressIndicator progressIndicator, Logger logger) throws KeywordSearchServiceException, InterruptedException {
        if (!caseNodeData.isDeletedFlagSet(CaseNodeData.DeletedFlags.TEXT_INDEX)) {
            logger.log(Level.INFO, String.format("Deleting text index for %s", caseNodeData.getDisplayName(), caseNodeData.getName(), caseNodeData.getDirectory())); //NON-NLS
            deleteTextIndex(metadata, progressIndicator);
            setDeletedItemFlag(caseNodeData, CaseNodeData.DeletedFlags.TEXT_INDEX);
        }
    }

    @Messages({
        "Case.progressMessage.deletingTextIndex=Deleting text index..."
    })
    private static void deleteTextIndex(CaseMetadata metadata, ProgressIndicator progressIndicator) throws KeywordSearchServiceException {
        progressIndicator.progress(Bundle.Case_progressMessage_deletingTextIndex());
 
        for (KeywordSearchService searchService : Lookup.getDefault().lookupAll(KeywordSearchService.class
        )) {
            searchService.deleteTextIndex(metadata);
        }
    }

    private static void deleteMultiUserCaseDirectory(CaseNodeData caseNodeData, CaseMetadata metadata, ProgressIndicator progressIndicator, Logger logger) throws CaseActionException, InterruptedException {
        if (!caseNodeData.isDeletedFlagSet(CaseNodeData.DeletedFlags.CASE_DIR)) {
            logger.log(Level.INFO, String.format("Deleting case directory for %s", caseNodeData.getDisplayName(), caseNodeData.getName(), caseNodeData.getDirectory())); //NON-NLS
            deleteCaseDirectory(metadata, progressIndicator);
            setDeletedItemFlag(caseNodeData, CaseNodeData.DeletedFlags.CASE_DIR);
        }
    }

    @Messages({
        "Case.progressMessage.deletingCaseDirectory=Deleting case directory..."
    })
    private static void deleteCaseDirectory(CaseMetadata metadata, ProgressIndicator progressIndicator) throws CaseActionException {
        progressIndicator.progress(Bundle.Case_progressMessage_deletingCaseDirectory());
        if (!FileUtil.deleteDir(new File(metadata.getCaseDirectory()))) {
            throw new CaseActionException(String.format("Failed to delete %s", metadata.getCaseDirectory())); //NON-NLS
        }
    }

    @Messages({
        "Case.progressMessage.removingCaseFromRecentCases=Removing case from Recent Cases menu..."
    })
    private static void deleteFromRecentCases(CaseMetadata metadata, ProgressIndicator progressIndicator) {
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator.progress(Bundle.Case_progressMessage_removingCaseFromRecentCases());
            SwingUtilities.invokeLater(() -> {
                RecentCases.getInstance().removeRecentCase(metadata.getCaseDisplayName(), metadata.getFilePath().toString());
            });
        }
    }

    private static boolean isNoNodeException(CoordinationServiceException ex) {
        boolean isNodeNodeEx = false;
        Throwable cause = ex.getCause();
        if (cause != null) {
            String causeMessage = cause.getMessage();
            isNodeNodeEx = causeMessage.contains(NO_NODE_ERROR_MSG_FRAGMENT);
        }
        return isNodeNodeEx;
    }

    private static void setDeletedItemFlag(CaseNodeData caseNodeData, CaseNodeData.DeletedFlags flag) throws InterruptedException {
        try {
            caseNodeData.setDeletedFlag(flag);
            CaseNodeData.writeCaseNodeData(caseNodeData);
        } catch (CaseNodeDataException ex) {
            logger.log(Level.SEVERE, String.format("Error updating deleted item flag %s for %s (%s) in %s", flag.name(), caseNodeData.getDisplayName(), caseNodeData.getName(), caseNodeData.getDirectory()), ex);
 
        }
    }

    private void updateDataParameters() throws TskCoreException {
        hasDataSource = dbHasDataSource();
 
        if (!hasDataSource) {
            hasData = dbHasData();
        } else {
            hasData = true;
        }
    }

    private boolean dbHasDataSource() throws TskCoreException {
        String query = "SELECT count(*) AS count FROM (SELECT * FROM data_source_info LIMIT 1)t";
        try (SleuthkitCase.CaseDbQuery dbQuery = caseDb.executeQuery(query)) {
            ResultSet resultSet = dbQuery.getResultSet();
            if (resultSet.next()) {
                return resultSet.getLong("count") > 0;
            }
            return false;
        } catch (SQLException ex) {
            logger.log(Level.SEVERE, "Error accessing case database", ex); //NON-NLS
            throw new TskCoreException("Error accessing case databse", ex);
        }
    }

    private boolean dbHasData() throws TskCoreException {
        // The LIMIT 1 in the subquery should limit the data returned and 
        // make the overall query more efficent.
        String query = "SELECT SUM(cnt) total FROM "
                + "(SELECT COUNT(*) AS cnt FROM "
                + "(SELECT * FROM tsk_objects LIMIT 1)t "
                + "UNION ALL "
                + "SELECT COUNT(*) AS cnt FROM "
                + "(SELECT * FROM tsk_hosts LIMIT 1)r) s";
        try (SleuthkitCase.CaseDbQuery dbQuery = caseDb.executeQuery(query)) {
            ResultSet resultSet = dbQuery.getResultSet();
            if (resultSet.next()) {
                return resultSet.getLong("total") > 0;
            } else {
                return false;
            }
        } catch (SQLException ex) {
            logger.log(Level.SEVERE, "Error accessing case database", ex); //NON-NLS
            throw new TskCoreException("Error accessing case databse", ex);
        }
    }

    private interface CaseAction<T, V, R> {

        R execute(T progressIndicator, V additionalParams) throws CaseActionException;
    }

    private enum CaseLockType {
        SHARED, EXCLUSIVE;
    }

    @ThreadSafe
    private final static class CancelButtonListener implements ActionListener {
 
        private final String cancellationMessage;
        @GuardedBy("this")
        private boolean cancelRequested;
        @GuardedBy("this")
        private CaseContext caseContext;
        @GuardedBy("this")
        private Future<?> caseActionFuture;

        private CancelButtonListener(String cancellationMessage) {
            this.cancellationMessage = cancellationMessage;
        }

        private synchronized void setCaseContext(CaseContext caseContext) {
            this.caseContext = caseContext;
            /*
             * If the cancel button has already been pressed, pass the
             * cancellation on to the case context.
             */
            if (cancelRequested) {
                cancel();
            }
        }

        private synchronized void setCaseActionFuture(Future<?> caseActionFuture) {
            this.caseActionFuture = caseActionFuture;
            /*
             * If the cancel button has already been pressed, cancel the Future
             * of the task.
             */
            if (cancelRequested) {
                cancel();
            }
        }

        @Override
        public synchronized void actionPerformed(ActionEvent event) {
            cancel();
        }

        private void cancel() {
            /*
             * At a minimum, set the cancellation requested flag of this
             * listener.
             */
            this.cancelRequested = true;
            if (null != this.caseContext) {
                /*
                 * Set the cancellation request flag and display the
                 * cancellation message in the progress indicator for the case
                 * context associated with this listener.
                 */
                if (RuntimeProperties.runningWithGUI()) {
                    ProgressIndicator progressIndicator = this.caseContext.getProgressIndicator();
                    if (progressIndicator instanceof ModalDialogProgressIndicator) {
                        ((ModalDialogProgressIndicator) progressIndicator).setCancelling(cancellationMessage);
                    }
                }
                this.caseContext.requestCancel();
            }
            if (null != this.caseActionFuture) {
                /*
                 * Cancel the Future of the task associated with this listener.
                 * Note that the task thread will be interrupted if the task is
                 * blocked.
                 */
                this.caseActionFuture.cancel(true);
            }
        }
    }

    private static class TaskThreadFactory implements ThreadFactory {
 
        private final String threadName;
 
        private TaskThreadFactory(String threadName) {
            this.threadName = threadName;
        }
 
        @Override
        public Thread newThread(Runnable task) {
            return new Thread(task, threadName);
        }
 
    }

    @Deprecated
    public static String getAppName() {
        return UserPreferences.getAppName();
    }

    @Deprecated
    public static void create(String caseDir, String caseDisplayName, String caseNumber, String examiner) throws CaseActionException {
        createAsCurrentCase(caseDir, caseDisplayName, caseNumber, examiner, CaseType.SINGLE_USER_CASE);
    }

    @Deprecated
    public static void create(String caseDir, String caseDisplayName, String caseNumber, String examiner, CaseType caseType) throws CaseActionException {
        createAsCurrentCase(caseDir, caseDisplayName, caseNumber, examiner, caseType);
    }

    @Deprecated
    public static void open(String caseMetadataFilePath) throws CaseActionException {
        openAsCurrentCase(caseMetadataFilePath);
    }

    @Deprecated
    public void closeCase() throws CaseActionException {
        closeCurrentCase();
    }

    @Deprecated
    public static void invokeStartupDialog() {
        StartupWindowProvider.getInstance().open();
    }

    @Deprecated
    public static String convertTimeZone(String timeZoneId) {
        return TimeZoneUtils.convertToAlphaNumericFormat(timeZoneId);
    }

    @Deprecated
    public static boolean pathExists(String filePath) {
        return new File(filePath).isFile();
    }

    @Deprecated
    public static String getAutopsyVersion() {
        return Version.getVersion();
    }

    @Deprecated
    public static boolean existsCurrentCase() {
        return isCaseOpen();
    }

    @Deprecated
    public static String getModulesOutputDirRelPath() {
        return "ModuleOutput"; //NON-NLS
    }

    @Deprecated
    public static PropertyChangeSupport
            getPropertyChangeSupport() {
        return new PropertyChangeSupport(Case.class
        );
    }

    @Deprecated
    public String getModulesOutputDirAbsPath() {
        return getModuleDirectory();
    }

    @Deprecated
    public Image addImage(String imgPath, long imgId, String timeZone) throws CaseActionException {
        try {
            Image newDataSource = caseDb.getImageById(imgId);
            notifyDataSourceAdded(newDataSource, UUID.randomUUID());
            return newDataSource;
        } catch (TskCoreException ex) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.addImg.exception.msg"), ex);
        }
    }

    @Deprecated
    public Set<TimeZone> getTimeZone() {
        return getTimeZones();
    }

    @Deprecated
    public void deleteReports(Collection<? extends Report> reports, boolean deleteFromDisk) throws TskCoreException {
        deleteReports(reports);
    }
 
}