Case.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2017 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 java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.File;
import java.io.IOException;
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.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
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.MissingResourceException;
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.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 static org.sleuthkit.autopsy.casemodule.Bundle.*;
import org.sleuthkit.autopsy.casemodule.CaseMetadata.CaseMetadataException;
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.ContentTagAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.ContentTagDeletedEvent;
import org.sleuthkit.autopsy.casemodule.events.DataSourceAddedEvent;
import org.sleuthkit.autopsy.casemodule.events.ReportAddedEvent;
import org.sleuthkit.autopsy.casemodule.services.Services;
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.TimeZoneUtils;
import org.sleuthkit.autopsy.coreutils.Version;
import org.sleuthkit.autopsy.events.AutopsyEvent;
import org.sleuthkit.autopsy.events.AutopsyEventException;
import org.sleuthkit.autopsy.events.AutopsyEventPublisher;
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.progress.LoggingProgressIndicator;
import org.sleuthkit.autopsy.progress.ModalDialogProgressIndicator;
import org.sleuthkit.autopsy.progress.ProgressIndicator;
import org.sleuthkit.autopsy.timeline.OpenTimelineAction;
import org.sleuthkit.datamodel.BlackboardArtifactTag;
import org.sleuthkit.datamodel.CaseDbConnectionInfo;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ContentTag;
import org.sleuthkit.datamodel.Image;
import org.sleuthkit.datamodel.Report;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskUnsupportedSchemaVersionException;

public class Case {

    private static final int DIR_LOCK_TIMOUT_HOURS = 12;
    private static final int RESOURCES_LOCK_TIMOUT_HOURS = 12;
    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 TEMP_FOLDER = "Temp"; //NON-NLS
    private static final String MODULE_FOLDER = "ModuleOutput"; //NON-NLS
    private static final long EXECUTOR_AWAIT_TIMEOUT_SECS = 5;
    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 Logger logger = Logger.getLogger(Case.class.getName());
    private static final AutopsyEventPublisher eventPublisher = new AutopsyEventPublisher();
    private static final Object caseActionSerializationLock = new Object();
    private static volatile Frame mainFrame;
    private static volatile Case currentCase;
    private final CaseMetadata metadata;
    private volatile ExecutorService caseLockingExecutor;
    private CoordinationService.Lock caseDirLock;
    private SleuthkitCase caseDb;
    private CollaborationMonitor collaborationMonitor;
    private Services caseServices;
    private boolean hasDataSources;

    /*
     * 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 {
        WindowManager.getDefault().invokeWhenUIReady(new Runnable() {
            @Override
            public void run() {
                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 {

        NAME,
        NUMBER,
        EXAMINER,
        ADDING_DATA_SOURCE,
        ADDING_DATA_SOURCE_FAILED,
        DATA_SOURCE_ADDED,
        DATA_SOURCE_DELETED,
        CURRENT_CASE,
        REPORT_ADDED,
        REPORT_DELETED,
        BLACKBOARD_ARTIFACT_TAG_ADDED,
        BLACKBOARD_ARTIFACT_TAG_DELETED,
        CONTENT_TAG_ADDED,
        CONTENT_TAG_DELETED;
    };

    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("|"));
    }

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

    @Messages({
        "Case.exceptionMessage.failedToReadMetadata=Failed to read case metadata.",
        "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);
        }
        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() {
        /*
         * Throwing an unchecked exception is a bad idea here.
         *
         * TODO (JIRA-2229): Case.getCurrentCase() method throws unchecked
         * IllegalStateException; change to throw checked exception or return
         * null
         */
        if (null != currentCase) {
            return currentCase;
        } else {
            throw new IllegalStateException(NbBundle.getMessage(Case.class, "Case.getCurCase.exception.noneOpen"));
        }
    }

    @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
                currentCase = null;
                closedCase.close();
                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 {
                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.deletingCase=Deleting Case",
        "Case.exceptionMessage.cannotDeleteCurrentCase=Cannot delete current case, it must be closed first.",
        "Case.progressMessage.checkingForOtherUser=Checking to see if another user has the case open...",
        "Case.exceptionMessage.cannotGetLockToDeleteCase=Cannot delete case because it is open for another user or there is a problem with the coordination service."
    })
    public static void deleteCase(CaseMetadata metadata) throws CaseActionException {
        synchronized (caseActionSerializationLock) {
            if (null != currentCase) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_cannotDeleteCurrentCase());
            }
        }

        /*
         * Set up either a GUI progress indicator without a cancel button (can't
         * cancel deleting a case) or a logging progress indicator.
         */
        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()) {
                deleteCase(metadata, progressIndicator);
            } else {
                /*
                 * First, acquire an exclusive case directory lock. The case
                 * cannot be deleted if another node has it open.
                 */
                progressIndicator.progress(Bundle.Case_progressMessage_checkingForOtherUser());
                try (CoordinationService.Lock dirLock = CoordinationService.getInstance().tryGetExclusiveLock(CategoryNode.CASES, metadata.getCaseDirectory())) {
                    assert (null != dirLock);
                    deleteCase(metadata, progressIndicator);
                } catch (CoordinationServiceException ex) {
                    throw new CaseActionException(Bundle.Case_exceptionMessage_cannotGetLockToDeleteCase(), ex);
                }
            }
        } finally {
            progressIndicator.finish();
        }
    }

    @Messages({
        "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
                newCurrentCase.open(isNewCase);
                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;
    }

    static void createCaseDirectory(String caseDir, CaseType caseType) throws CaseActionException {

        File caseDirF = new File(caseDir);

        if (caseDirF.exists()) {
            if (caseDirF.isFile()) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existNotDir", caseDir));

            } else if (!caseDirF.canRead() || !caseDirF.canWrite()) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existCantRW", caseDir));
            }
        }

        try {
            boolean result = (caseDirF).mkdirs(); // create root case Directory

            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreate", caseDir));
            }

            // create the folders inside the case directory
            String hostClause = "";

            if (caseType == CaseType.MULTI_USER_CASE) {
                hostClause = File.separator + NetworkUtils.getLocalHostName();
            }
            result = result && (new File(caseDir + hostClause + File.separator + EXPORT_FOLDER)).mkdirs()
                    && (new File(caseDir + hostClause + File.separator + LOG_FOLDER)).mkdirs()
                    && (new File(caseDir + hostClause + File.separator + TEMP_FOLDER)).mkdirs()
                    && (new File(caseDir + hostClause + File.separator + CACHE_FOLDER)).mkdirs();

            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateCaseDir", caseDir));
            }

            final String modulesOutDir = caseDir + hostClause + File.separator + MODULE_FOLDER;
            result = new File(modulesOutDir).mkdir();

            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateModDir",
                                modulesOutDir));
            }

            final String reportsOutDir = caseDir + hostClause + File.separator + REPORTS_FOLDER;
            result = new File(reportsOutDir).mkdir();

            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateReportsDir",
                                modulesOutDir));

            }

        } catch (MissingResourceException | CaseActionException e) {
            throw new CaseActionException(
                    NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.gen", caseDir), e);
        }
    }

    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.progressMessage.deletingTextIndex=Deleting text index...",
        "Case.progressMessage.deletingCaseDatabase=Deleting case database...",
        "Case.progressMessage.deletingCaseDirectory=Deleting case directory...",
        "Case.exceptionMessage.errorsDeletingCase=Errors occured while deleting the case. See the application log for details"
    })
    private static void deleteCase(CaseMetadata metadata, ProgressIndicator progressIndicator) throws CaseActionException {
        boolean errorsOccurred = false;
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
            /*
             * Delete the case database from the database server.
             */
            try {
                progressIndicator.progress(Bundle.Case_progressMessage_deletingCaseDatabase());
                CaseDbConnectionInfo db;
                db = UserPreferences.getDatabaseConnectionInfo();
                Class.forName("org.postgresql.Driver"); //NON-NLS
                try (Connection connection = DriverManager.getConnection("jdbc:postgresql://" + db.getHost() + ":" + db.getPort() + "/postgres", db.getUserName(), db.getPassword()); //NON-NLS
                        Statement statement = connection.createStatement();) {
                    String deleteCommand = "DROP DATABASE \"" + metadata.getCaseDatabaseName() + "\""; //NON-NLS
                    statement.execute(deleteCommand);
                }
            } catch (UserPreferencesException | ClassNotFoundException | SQLException ex) {
                logger.log(Level.SEVERE, String.format("Failed to delete case database %s for %s (%s) in %s", metadata.getCaseDatabaseName(), metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex);
                errorsOccurred = true;
            }
        }

        /*
         * Delete the text index.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_deletingTextIndex());
        for (KeywordSearchService searchService : Lookup.getDefault().lookupAll(KeywordSearchService.class)) {
            try {
                searchService.deleteTextIndex(metadata);
            } catch (KeywordSearchServiceException ex) {
                logger.log(Level.SEVERE, String.format("Failed to delete text index for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()), ex);
                errorsOccurred = true;
            }
        }

        /*
         * Delete the case directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_deletingCaseDirectory());
        if (!FileUtil.deleteDir(new File(metadata.getCaseDirectory()))) {
            logger.log(Level.SEVERE, String.format("Failed to delete case directory for %s (%s) in %s", metadata.getCaseDisplayName(), metadata.getCaseName(), metadata.getCaseDirectory()));
            errorsOccurred = true;
        }

        /*
         * If running in a GUI, remove the case from the Recent Cases menu
         */
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> {
                RecentCases.getInstance().removeRecentCase(metadata.getCaseDisplayName(), metadata.getFilePath().toString());
            });
        }

        if (errorsOccurred) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_errorsDeletingCase());
        }
    }

    @Messages({"Case.creationException.couldNotAcquireResourcesLock=Failed to get lock on case resources"})
    private static CoordinationService.Lock acquireExclusiveCaseResourcesLock(String caseDir) throws CaseActionException {
        try {
            String resourcesNodeName = caseDir + "_resources";
            Lock lock = CoordinationService.getInstance().tryGetExclusiveLock(CategoryNode.CASES, resourcesNodeName, RESOURCES_LOCK_TIMOUT_HOURS, TimeUnit.HOURS);
            if (null == lock) {
                throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock());
            }
            return lock;
        } catch (InterruptedException ex) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        } catch (CoordinationServiceException ex) {
            throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock(), ex);
        }
    }

    private static void updateGUIForCaseOpened(Case newCurrentCase) {
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> {
                /*
                 * 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).isFile() || DriveUtils.driveExists(path));
                    if (!fileExists) {
                        int response = JOptionPane.showConfirmDialog(
                                mainFrame,
                                NbBundle.getMessage(Case.class, "Case.checkImgExist.confDlg.doesntExist.msg", 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

                        }
                    }
                }

                /*
                 * Enable the case-specific actions.
                 */
                CallableSystemAction.get(AddImageAction.class).setEnabled(true);
                CallableSystemAction.get(CaseCloseAction.class).setEnabled(true);
                CallableSystemAction.get(CasePropertiesAction.class).setEnabled(true);
                CallableSystemAction.get(CaseDeleteAction.class).setEnabled(true);
                CallableSystemAction.get(OpenTimelineAction.class).setEnabled(true);
                CallableSystemAction.get(OpenOutputFolderAction.class).setEnabled(false);

                /*
                 * 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());

                /*
                 * Open the top components (windows within the main application
                 * window).
                 */
                if (newCurrentCase.hasData()) {
                    CoreComponentControl.openCoreWindows();
                }

                /*
                 * Reset the main window title to:
                 *
                 * [curent case display name] - [application name].
                 */
                mainFrame.setTitle(newCurrentCase.getDisplayName() + " - " + UserPreferences.getAppName());
            });
        }
    }

    /*
     * 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(CaseCloseAction.class
                        ).setEnabled(false);
                CallableSystemAction
                        .get(CasePropertiesAction.class
                        ).setEnabled(false);
                CallableSystemAction
                        .get(CaseDeleteAction.class
                        ).setEnabled(false);
                CallableSystemAction
                        .get(OpenTimelineAction.class
                        ).setEnabled(false);
                CallableSystemAction
                        .get(OpenOutputFolderAction.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(UserPreferences.getAppName());
            });
        }
    }

    private static void clearTempSubDir(String tempSubDirPath) {
        File tempFolder = new File(tempSubDirPath);
        if (tempFolder.isDirectory()) {
            File[] files = tempFolder.listFiles();
            if (files.length > 0) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        FileUtil.deleteDir(file);
                    } else {
                        file.delete();
                    }
                }
            }
        }
    }

    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 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();
    }

    public String getTempDirectory() {
        return getOrCreateSubdirectory(TEMP_FOLDER);
    }

    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 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 {
        List<Content> list = caseDb.getRootObjects();
        hasDataSources = (list.size() > 0);
        return list;
    }

    public Set<TimeZone> getTimeZones() {
        Set<TimeZone> timezones = new HashSet<>();
        try {
            for (Content c : getDataSources()) {
                final Content dataSource = c.getDataSource();
                if ((dataSource != null) && (dataSource instanceof Image)) {
                    Image image = (Image) dataSource;
                    timezones.add(TimeZone.getTimeZone(image.getTimeZone()));
                }
            }
        } catch (TskCoreException 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() {
        if (!hasDataSources) {
            try {
                hasDataSources = (getDataSources().size() > 0);
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, "Error accessing case database", ex); //NON-NLS
            }
        }
        return hasDataSources;
    }

    public void notifyAddingDataSource(UUID eventId) {
        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 notifyContentTagAdded(ContentTag newTag) {
        eventPublisher.publish(new ContentTagAddedEvent(newTag));
    }

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

    public void notifyBlackBoardArtifactTagAdded(BlackboardArtifactTag newTag) {
        eventPublisher.publish(new BlackBoardArtifactTagAddedEvent(newTag));
    }

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

    public void addReport(String localPath, String srcModuleName, String reportName) throws TskCoreException {
        String normalizedLocalPath;
        try {
            normalizedLocalPath = Paths.get(localPath).normalize().toString();
        } catch (InvalidPathException ex) {
            String errorMsg = "Invalid local path provided: " + localPath; // NON-NLS
            throw new TskCoreException(errorMsg, ex);
        }
        Report report = this.caseDb.addReport(normalizedLocalPath, srcModuleName, reportName);
        eventPublisher.publish(new ReportAddedEvent(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);
            eventPublisher.publish(new AutopsyEvent(Events.REPORT_DELETED.toString(), report, null));
        }
    }

    CaseMetadata getMetadata() {
        return metadata;
    }

    @Messages({
        "Case.exceptionMessage.metadataUpdateError=Failed to update case metadata, cannot change case display name."
    })
    void updateDisplayName(String newDisplayName) throws CaseActionException {
        String oldDisplayName = metadata.getCaseDisplayName();
        try {
            metadata.setCaseDisplayName(newDisplayName);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_metadataUpdateError());
        }
        eventPublisher.publish(new AutopsyEvent(Events.NAME.toString(), oldDisplayName, newDisplayName));
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> {
                mainFrame.setTitle(newDisplayName + " - " + UserPreferences.getAppName());
                try {
                    RecentCases.getInstance().updateRecentCase(oldDisplayName, metadata.getFilePath().toString(), newDisplayName, 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, String caseDisplayName, String caseNumber, String examiner) {
        metadata = new CaseMetadata(caseDir, caseType, displayNameToUniqueName(caseDisplayName), caseDisplayName, caseNumber, examiner);
    }

    private Case(CaseMetadata caseMetaData) {
        metadata = caseMetaData;
    }

    @Messages({
        "Case.progressIndicatorTitle.creatingCase=Creating Case",
        "Case.progressIndicatorTitle.openingCase=Opening Case",
        "Case.progressIndicatorCancelButton.label=Cancel",
        "Case.progressMessage.preparing=Preparing...",
        "Case.progressMessage.preparingToOpenCaseResources=<html>Preparing to open case resources.<br>This may take time if another user is upgrading the case.</html>",
        "Case.progressMessage.cancelling=Cancelling...",
        "Case.exceptionMessage.cancelledByUser=Cancelled by user.",
        "# {0} - exception message", "Case.exceptionMessage.execExceptionWrapperMessage={0}"
    })
    private void open(boolean isNewCase) throws CaseActionException {
        /*
         * Create and start either a GUI progress indicator with a Cancel button
         * or a logging progress indicator.
         */
        CancelButtonListener cancelButtonListener = null;
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            cancelButtonListener = new CancelButtonListener(Bundle.Case_progressMessage_cancelling());
            String progressIndicatorTitle = isNewCase ? Bundle.Case_progressIndicatorTitle_creatingCase() : Bundle.Case_progressIndicatorTitle_openingCase();
            progressIndicator = new ModalDialogProgressIndicator(
                    mainFrame,
                    progressIndicatorTitle,
                    new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                    Bundle.Case_progressIndicatorCancelButton_label(),
                    cancelButtonListener);
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());

        /*
         * Creating/opening a case is always done by creating a task running in
         * the same non-UI thread that will be used to close the case, so a
         * single-threaded executor service is created here and saved as case
         * state (must be volatile for cancellation to work).
         *
         * --- If the case is a single-user case, this supports cancelling
         * opening of the case by cancelling the task.
         *
         * --- If the case is a multi-user case, this still supports
         * cancellation, but it also makes it possible for the shared case
         * directory lock held as long as the case is open to be released in the
         * same thread in which it was acquired, as is required by the
         * coordination service.
         */
        TaskThreadFactory threadFactory = new TaskThreadFactory(String.format(CASE_ACTION_THREAD_NAME, metadata.getCaseName()));
        caseLockingExecutor = Executors.newSingleThreadExecutor(threadFactory);
        Future<Void> future = caseLockingExecutor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                open(isNewCase, progressIndicator);
            } else {
                /*
                 * First, acquire a shared case directory lock that will be held
                 * as long as this node has this case open. This will prevent
                 * deletion of the case by another node. Next, 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_preparingToOpenCaseResources());
                acquireSharedCaseDirLock(metadata.getCaseDirectory());
                try (CoordinationService.Lock resourcesLock = acquireExclusiveCaseResourcesLock(metadata.getCaseDirectory())) {
                    assert (null != resourcesLock);
                    open(isNewCase, progressIndicator);
                } catch (CaseActionException ex) {
                    releaseSharedCaseDirLock(getMetadata().getCaseDirectory());
                    throw ex;
                }
            }
            return null;
        });
        if (null != cancelButtonListener) {
            cancelButtonListener.setCaseActionFuture(future);
        }

        /*
         * Wait for the case creation/opening task to finish.
         */
        try {
            future.get();
        } catch (InterruptedException discarded) {
            /*
             * The thread this method is running in has been interrupted. Cancel
             * the create/open task, wait for it to finish, and shut down the
             * executor. This can be done safely because if the task is
             * completed with a cancellation condition, the case will have been
             * closed and the case directory lock released will have been
             * released.
             */
            if (null != cancelButtonListener) {
                cancelButtonListener.actionPerformed(null);
            } else {
                future.cancel(true);
            }
            Case.shutDownTaskExecutor(caseLockingExecutor);
        } catch (CancellationException discarded) {
            /*
             * The create/open task has been cancelled. Wait for it to finish,
             * and shut down the executor. This can be done safely because if
             * the task is completed with a cancellation condition, the case
             * will have been closed and the case directory lock released will
             * have been released.
             */
            Case.shutDownTaskExecutor(caseLockingExecutor);
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        } catch (ExecutionException ex) {
            /*
             * The create/open task has thrown an exception. Wait for it to
             * finish, and shut down the executor. This can be done safely
             * because if the task is completed with an execution condition, the
             * case will have been closed and the case directory lock released
             * will have been released.
             */
            Case.shutDownTaskExecutor(caseLockingExecutor);
            throw new CaseActionException(Bundle.Case_exceptionMessage_execExceptionWrapperMessage(ex.getCause().getLocalizedMessage()), ex);
        } finally {
            progressIndicator.finish();
        }
    }

    private void open(boolean isNewCase, ProgressIndicator progressIndicator) throws CaseActionException {
        try {
            if (Thread.currentThread().isInterrupted()) {
                throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
            }

            if (isNewCase) {
                createCaseData(progressIndicator);
            } else {
                openCaseData(progressIndicator);
            }

            if (Thread.currentThread().isInterrupted()) {
                throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
            }

            openServices(progressIndicator);

            if (Thread.currentThread().isInterrupted()) {
                throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
            }
        } catch (CaseActionException ex) {
            /*
             * Cancellation or failure. Clean up. 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 this thread.
             */
            try {
                Thread.sleep(1);
            } catch (InterruptedException discarded) {
            }
            close(progressIndicator);
            throw ex;
        }
    }

    @Messages({
        "Case.progressMessage.creatingCaseDirectory=Creating case directory...",
        "Case.progressMessage.creatingCaseDatabase=Creating case database...",
        "# {0} - exception message", "Case.exceptionMessage.couldNotCreateCaseDatabase=Failed to create case database:\n{0}",
        "Case.exceptionMessage.couldNotCreateMetadataFile=Failed to create case metadata file."
    })
    private void createCaseData(ProgressIndicator progressIndicator) throws CaseActionException {
        /*
         * Create the case directory, if it does not already exist.
         *
         * TODO (JIRA-2180): Always create the case directory as part of the
         * case creation process.
         */
        if (new File(metadata.getCaseDirectory()).exists() == false) {
            progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDirectory());
            Case.createCaseDirectory(metadata.getCaseDirectory(), metadata.getCaseType());
        }

        /*
         * Create the case database.
         */
        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 root of the
                 * case directory.
                 */
                caseDb = SleuthkitCase.newCase(Paths.get(metadata.getCaseDirectory(), SINGLE_USER_CASE_DB_NAME).toString());
                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 a database server.
                 */
                caseDb = SleuthkitCase.newCase(metadata.getCaseDisplayName(), UserPreferences.getDatabaseConnectionInfo(), metadata.getCaseDirectory());
                metadata.setCaseDatabaseName(caseDb.getDatabaseName());
            }
        } catch (TskCoreException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateCaseDatabase(ex.getLocalizedMessage()), ex);
        } catch (UserPreferencesException ex) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.databaseConnectionInfo.error.msg"), ex);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateMetadataFile(), ex);
        }
    }

    @Messages({
        "Case.progressMessage.openingCaseDatabase=Opening case database...",
        "Case.exceptionMessage.couldNotOpenCaseDatabase=Failed to open case database.",
        "Case.unsupportedSchemaVersionMessage=Unsupported DB schema version - see log for details",
        "Case.databaseConnectionInfo.error.msg=Error accessing database server connection info. See Tools, Options, Multi-User.",
        "Case.open.exception.multiUserCaseNotEnabled=Cannot open a multi-user case if multi-user cases are not enabled. "
        + "See Tools, Options, Multi-user."
    })
    private void openCaseData(ProgressIndicator progressIndicator) throws CaseActionException {
        try {
            progressIndicator.progress(Bundle.Case_progressMessage_openingCaseDatabase());
            String databaseName = metadata.getCaseDatabaseName();
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                caseDb = SleuthkitCase.openCase(Paths.get(metadata.getCaseDirectory(), databaseName).toString());
            } else if (UserPreferences.getIsMultiUserModeEnabled()) {
                try {
                    caseDb = SleuthkitCase.openCase(databaseName, UserPreferences.getDatabaseConnectionInfo(), metadata.getCaseDirectory());
                } catch (UserPreferencesException ex) {
                    throw new CaseActionException(Case_databaseConnectionInfo_error_msg(), ex);
                }
            } else {
                throw new CaseActionException(Case_open_exception_multiUserCaseNotEnabled());
            }
        } catch (TskUnsupportedSchemaVersionException ex) {
            throw new CaseActionException(Bundle.Case_unsupportedSchemaVersionMessage(), ex);
        } catch (TskCoreException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotOpenCaseDatabase(), ex);
        }
    }

    @Messages({
        "Case.progressMessage.switchingLogDirectory=Switching log directory...",
        "Case.progressMessage.clearingTempDirectory=Clearing case temp directory...",
        "Case.progressMessage.openingCaseLevelServices=Opening case-level services...",
        "Case.progressMessage.openingApplicationServiceResources=Opening application service case resources...",
        "Case.progressMessage.settingUpNetworkCommunications=Setting up network communications...",})
    private void openServices(ProgressIndicator progressIndicator) throws CaseActionException {
        /*
         * Switch to writing to the application logs in the logs subdirectory of
         * the case directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_switchingLogDirectory());
        Logger.setLogDirectory(getLogDirectoryPath());
        if (Thread.currentThread().isInterrupted()) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        }

        /*
         * Clear the temp subdirectory of the case directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_clearingTempDirectory());
        Case.clearTempSubDir(this.getTempDirectory());
        if (Thread.currentThread().isInterrupted()) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        }

        /*
         * Open the case-level services.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_openingCaseLevelServices());
        this.caseServices = new Services(caseDb);
        if (Thread.currentThread().isInterrupted()) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        }

        /*
         * Allow any registered application services to open any resources
         * specific to this case.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_openingApplicationServiceResources());
        openAppServiceCaseResources();
        if (Thread.currentThread().isInterrupted()) {
            throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
        }

        /*
         * If this case is a multi-user case, set up for communication with
         * other nodes.
         */
        if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
            progressIndicator.progress(Bundle.Case_progressMessage_settingUpNetworkCommunications());
            try {
                eventPublisher.openRemoteEventChannel(String.format(EVENT_CHANNEL_NAME, metadata.getCaseName()));
                if (Thread.currentThread().isInterrupted()) {
                    throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
                }
                collaborationMonitor = new CollaborationMonitor(metadata.getCaseName());
            } catch (AutopsyEventException | CollaborationMonitor.CollaborationMonitorException ex) {
                /*
                 * The collaboration monitor and event channel are not
                 * essential. Log an error and notify the user, but do not
                 * throw.
                 */
                logger.log(Level.SEVERE, "Failed to setup network communications", ex); //NON-NLS
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> MessageNotifyUtil.Notify.error(
                            NbBundle.getMessage(Case.class, "Case.CollaborationSetup.FailNotify.Title"),
                            NbBundle.getMessage(Case.class, "Case.CollaborationSetup.FailNotify.ErrMsg")));
                }
            }
        }
    }

    @NbBundle.Messages({
        "# {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() 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.
         */
        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 progressIndicator;
            if (RuntimeProperties.runningWithGUI()) {
                cancelButtonListener = new CancelButtonListener(Bundle.Case_serviceOpenCaseResourcesProgressIndicator_cancellingMessage(service.getServiceName()));
                progressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        Bundle.Case_serviceOpenCaseResourcesProgressIndicator_title(service.getServiceName()),
                        new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                        Bundle.Case_progressIndicatorCancelButton_label(),
                        cancelButtonListener);
            } 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.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.
                 */
                shutDownTaskExecutor(executor);
                progressIndicator.finish();
            }

            if (Thread.currentThread().isInterrupted()) {
                throw new CaseActionCancelledException(Bundle.Case_exceptionMessage_cancelledByUser());
            }
        }
    }

    private void close() 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 directory 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 = caseLockingExecutor.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 = acquireExclusiveCaseResourcesLock(metadata.getCaseDirectory())) {
                    assert (null != resourcesLock);
                    close(progressIndicator);
                } finally {
                    /*
                     * Always release the case directory lock that was acquired
                     * when the case was opened.
                     */
                    releaseSharedCaseDirLock(metadata.getCaseName());
                }
            }
            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. Likewsie, cancellation of the case closing task is
             * not supported.
             */
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_execExceptionWrapperMessage(ex.getCause().getMessage()), ex);
        } finally {
            shutDownTaskExecutor(caseLockingExecutor);
            progressIndicator.finish();
        }
    }

    @Messages({
        "Case.progressMessage.shuttingDownNetworkCommunications=Shutting down network communications...",
        "Case.progressMessage.closingApplicationServiceResources=Closing case-specific application service resources...",
        "Case.progressMessage.closingCaseLevelServices=Closing case-level services...",
        "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-level services.
         */
        if (null != caseServices) {
            progressIndicator.progress(Bundle.Case_progressMessage_closingCaseLevelServices());
            try {
                this.caseServices.close();
            } catch (IOException ex) {
                logger.log(Level.SEVERE, String.format("Error closing internal case services for %s at %s", this.getName(), this.getCaseDirectory()), ex);
            }
        }

        /*
         * Close the case database
         */
        if (null != caseDb) {
            progressIndicator.progress(Bundle.Case_progressMessage_closingCaseDatabase());
            caseDb.close();
        }

        /*
         * 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 {
                shutDownTaskExecutor(executor);
                progressIndicator.finish();
            }
        }
    }

    @Messages({"Case.creationException.couldNotAcquireDirLock=Failed to get lock on case directory."})
    private void acquireSharedCaseDirLock(String caseDir) throws CaseActionException {
        try {
            caseDirLock = CoordinationService.getInstance().tryGetSharedLock(CategoryNode.CASES, caseDir, DIR_LOCK_TIMOUT_HOURS, TimeUnit.HOURS);
            if (null == caseDirLock) {
                throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireDirLock());
            }
        } catch (InterruptedException | CoordinationServiceException ex) {
            throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireDirLock(), ex);
        }
    }

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

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

    }

    private static void shutDownTaskExecutor(ExecutorService executor) {
        executor.shutdown();
        boolean taskCompleted = false;
        while (!taskCompleted) {
            try {
                taskCompleted = executor.awaitTermination(EXECUTOR_AWAIT_TIMEOUT_SECS, TimeUnit.SECONDS);
            } catch (InterruptedException ignored) {
                /*
                 * The current policy is to wait for the task to finish so that
                 * the case can be left in a consistent state.
                 *
                 * For a specific example of the motivation for this policy,
                 * note that a application service (Solr search service)
                 * experienced an error condition when opening case resources
                 * that left the service blocked uninterruptibly on a socket
                 * read. This eventually led to a mysterious "freeze" as the
                 * user-cancelled service task continued to run holdiong a lock
                 * that a UI thread soon tried to acquire. Thus it has been
                 * deemed better to make the "freeze" happen in a more
                 * informative way, i.e., with the progress indicator for the
                 * unfinished task on the screen, if a similar error condition
                 * arises again.
                 */
            }
        }
    }

    @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);
    }

}