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.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.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.TimeUnit;
import java.util.logging.Level;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.concurrent.GuardedBy;
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.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.framework.AutopsyService;
import org.sleuthkit.autopsy.framework.AutopsyService.CaseContext;
import org.sleuthkit.autopsy.framework.LoggingProgressIndicator;
import org.sleuthkit.autopsy.framework.ModalDialogProgressIndicator;
import org.sleuthkit.autopsy.framework.ProgressIndicator;
import org.sleuthkit.autopsy.ingest.IngestJob;
import org.sleuthkit.autopsy.ingest.IngestManager;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchService;
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;

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 int MIN_SECS_BETWEEN_TSK_ERROR_REPORTS = 60;
    private static final String MODULE_FOLDER = "ModuleOutput"; //NON-NLS
    private static final Logger logger = Logger.getLogger(Case.class.getName());
    private static final AutopsyEventPublisher eventPublisher = new AutopsyEventPublisher();

    /*
     * The following fields are the mutable state associated with the current
     * case concept. The currentCase field is guarded for writes by the
     * currentCaseWriteLock. The field is also volatile to allow non-locking
     * reads via the isCaseOpen and getCurrentCase methods. This is unfortunate,
     * but Case clients that do not respond correctly to CURRENT_CASE closed
     * events may call these methods and that would be a source of potential
     * deadlock if the currentCaseWriteLock was used to guard read access.
     *
     * TODO (JIRA-2228): Throw CaseClosedException from Case instance methods.
     */
    private static final Object currentCaseWriteLock = new Object();
    @GuardedBy("currentCaseWriteLock")
    private static volatile Case currentCase;

    /*
     * The application name, used to make the title of the main application
     * window [application name] when there is no open case and [curent case
     * display name] - [application name] when there is an open case.
     * Initialized by getting the main window title before a case has been
     * opened. A reference to the main window frame is obtained at the same time
     * as a convenmient side effect for parenting dialogs.
     *
     * TODO (JIRA-2231): Make the application name a RuntimeProperties item.
     */
    @GuardedBy("currentCaseWriteLock")
    private static Frame mainFrame;
    @GuardedBy("currentCaseWriteLock")
    private static String appName;

    /*
     * Case instance data.
     */
    private CaseMetadata caseMetadata;
    private CoordinationService.Lock caseDirLock;
    private ExecutorService caseLockingExecutor;
    private SleuthkitCase caseDb;
    private SleuthkitErrorReporter sleuthkitErrorReporter;
    private CollaborationMonitor collaborationMonitor;
    private Services caseServices;
    private boolean hasDataSources;

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

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

    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 boolean isValidName(String caseName) {
        return !(caseName.contains("\\") || caseName.contains("/") || caseName.contains(":")
                || caseName.contains("*") || caseName.contains("?") || caseName.contains("\"")
                || caseName.contains("<") || caseName.contains(">") || caseName.contains("|"));
    }

    @Messages({
        "# {0} - exception message", "Case.exceptionMessage.wrapperMessage={0}"
    })
    public static void createAsCurrentCase(String caseDir, String caseDisplayName, String caseNumber, String examiner, CaseType caseType) throws CaseActionException {
        synchronized (currentCaseWriteLock) {
            if (RuntimeProperties.runningWithGUI()) {
                getMainWindowAndAppName();
            }

            if (null != currentCase) {
                String previousCaseDisplayName = currentCase.getDisplayName();
                String previousCaseName = currentCase.getName();
                String previousCaseDir = currentCase.getCaseDirectory();
                try {
                    closeCurrentCase();
                } catch (CaseActionException ex) {
                    logger.log(Level.SEVERE, String.format("Error closing the previous current case %s (%s) in %s", previousCaseDisplayName, previousCaseName, previousCaseDir), ex); //NON-NLS 
                }
            }

            logger.log(Level.INFO, "Creating current case {0} in {1}", new Object[]{caseDisplayName, caseDir}); //NON-NLS  
            Case newCurrentCase = new Case();
            newCurrentCase.create(caseType, caseDir, caseDisplayName, caseNumber, examiner);
            currentCase = newCurrentCase;
            logger.log(Level.INFO, "Created currrent case {0} ({1}) in {2}", new Object[]{newCurrentCase.getDisplayName(), newCurrentCase.getName(), newCurrentCase.getCaseDirectory()}); //NON-NLS
            if (RuntimeProperties.runningWithGUI()) {
                updateGUIForCaseOpened(newCurrentCase);
            }
            eventPublisher.publishLocally(new AutopsyEvent(Events.CURRENT_CASE.toString(), null, newCurrentCase));
        }
    }

    @Messages({
        "# {0} - exception message", "Case.openException.couldNotOpenCase=Could not open case: {0}",
        "Case.progressIndicatorTitle.openingCase=Opening Case",
        "Case.exceptionMessage.failedToReadMetadata=Failed to read metadata."
    })
    public static void openAsCurrentCase(String caseMetadataFilePath) throws CaseActionException {
        synchronized (currentCaseWriteLock) {
            if (RuntimeProperties.runningWithGUI()) {
                getMainWindowAndAppName();
            }

            if (null != currentCase) {
                try {
                    closeCurrentCase();
                } catch (CaseActionException ex) {
                    logger.log(Level.SEVERE, "Error closing the previous current case", ex);
                }
            }

            Case newCurrentCase = new Case();
            logger.log(Level.INFO, "Opening case with metadata file path {0} as current case", caseMetadataFilePath); //NON-NLS
            newCurrentCase.open(Paths.get(caseMetadataFilePath));
            currentCase = newCurrentCase;
            logger.log(Level.INFO, "Opened case with metadata file path {0} as current case", caseMetadataFilePath); //NON-NLS                
            if (RuntimeProperties.runningWithGUI()) {
                updateGUIForCaseOpened(newCurrentCase);
            }
            eventPublisher.publishLocally(new AutopsyEvent(Events.CURRENT_CASE.toString(), null, currentCase));
        }
    }

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

    public static Case getCurrentCase() {
        Case caseToReturn = currentCase;
        if (null != caseToReturn) {
            return caseToReturn;
        } 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 (currentCaseWriteLock) {
            if (null == currentCase) {
                return;
            }
            String caseName = currentCase.getName();
            String caseDir = currentCase.getCaseDirectory();
            try {
                Case closedCase = currentCase;
                eventPublisher.publishLocally(new AutopsyEvent(Events.CURRENT_CASE.toString(), closedCase, null));
                logger.log(Level.INFO, "Closing current case {0} in {1}", new Object[]{caseName, caseDir}); //NON-NLS
                currentCase = null;
                closedCase.close();
            } finally {
                /*
                 * The case is no longer the current case, even if an exception
                 * was thrown.
                 */
                logger.log(Level.INFO, "Closed current case {0} in {1}", new Object[]{caseName, caseDir}); //NON-NLS
                if (RuntimeProperties.runningWithGUI()) {
                    updateGUIForCaseClosed();
                }
            }
        }
    }

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

    @Messages({
        "# {0} - exception message", "Case.deleteException.couldNotDeleteCase=Could not delete case: {0}",
        "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.progressMessage.deletingTextIndex=Deleting text index...",
        "Case.progressMessage.deletingCaseDatabase=Deleting case database...",
        "Case.exceptionMessage.cancelled=Cancelled by user"
    })
    public static void deleteCase(CaseMetadata metadata) throws CaseActionException {
        synchronized (currentCaseWriteLock) {
            if (null != currentCase && 0 == metadata.getCaseDirectory().compareTo(metadata.getCaseDirectory())) {
                throw new CaseActionException(Bundle.Case_deleteException_couldNotDeleteCase(Bundle.Case_exceptionMessage_cannotDeleteCurrentCase()));
            }
        }

        /*
         * Set up either a GUI progress indicator 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());

        logger.log(Level.INFO, "Deleting case with metadata file path {0}", metadata.getFilePath()); //NON-NLS
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Void> future = executor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == metadata.getCaseType()) {
                cleanupDeletedCase(metadata, progressIndicator);
            } else {
                /*
                 * First, acquire an exclusive case directory lock. The case
                 * cannot be deleted if another node has it open.
                 */
                progressIndicator.start(Bundle.Case_progressMessage_checkingForOtherUser());
                try (CoordinationService.Lock dirLock = CoordinationService.getInstance().tryGetExclusiveLock(CategoryNode.CASES, metadata.getCaseDirectory())) {
                    assert (null != dirLock);

                    /*
                     * Delete the text index.
                     */
                    progressIndicator.start(Bundle.Case_progressMessage_deletingTextIndex());
                    for (KeywordSearchService searchService : Lookup.getDefault().lookupAll(KeywordSearchService.class)) {
                        searchService.deleteTextIndex(metadata);
                    }

                    if (CaseType.MULTI_USER_CASE == metadata.getCaseType()) {
                        /*
                         * Delete the case database from the database server.
                         * The case database for a single-user case is in the
                         * case directory and will be deleted whe it is deleted.
                         */
                        progressIndicator.start(Bundle.Case_progressMessage_deletingCaseDatabase());
                        CaseDbConnectionInfo 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);
                        }
                    }

                    cleanupDeletedCase(metadata, progressIndicator);
                }
            }
            return null;
        });

        try {
            future.get();
            logger.log(Level.INFO, "Deleted case with metadata file path {0}", metadata.getFilePath()); //NON-NLS            
        } catch (InterruptedException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getMessage()), ex);
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getCause().getMessage()), ex);
        } catch (CancellationException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_cancelled(), ex);
        } finally {
            executor.shutdown();
        }
    }

    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.exceptionMessage.cannotLocateMainWindow=Cannot locate main application window"
    })
    private static void getMainWindowAndAppName() throws CaseActionException {
        if (RuntimeProperties.runningWithGUI() && null == mainFrame) {
            try {
                SwingUtilities.invokeAndWait(() -> {
                    mainFrame = WindowManager.getDefault().getMainWindow();
                    /*
                     * This is tricky and fragile. What looks like lazy
                     * initialization of the appName field is actually getting
                     * the application name from the main window title BEFORE a
                     * case has been opened and a case name has been included in
                     * the title. It is also very specific to the desktop GUI.
                     *
                     * TODO (JIRA-2231): Make the application name a
                     * RuntimeProperties item set by Installers.
                     */
                    appName = mainFrame.getTitle();
                });
            } catch (InterruptedException | InvocationTargetException ex) {
                throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(Bundle.Case_exceptionMessage_cannotLocateMainWindow()), ex);
            }
        }
    }

    @Messages({
        "Case.progressMessage.deletingCaseDirectory=Deleting case directory..."
    })
    private static void cleanupDeletedCase(CaseMetadata metadata, ProgressIndicator progressIndicator) {
        /*
         * Delete the case directory.
         */
        progressIndicator.start(Bundle.Case_progressMessage_deletingCaseDirectory());
        if (!FileUtil.deleteDir(new File(metadata.getCaseDirectory()))) {
            logger.log(Level.SEVERE, "Failed to fully delete case directory {0}", metadata.getCaseDirectory());
        }

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

    @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 | CoordinationServiceException ex) {
            throw new CaseActionException(Bundle.Case_creationException_couldNotAcquireResourcesLock(), ex);
        }
    }

    private static void updateGUIForCaseOpened(Case newCurrentCase) {
        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(
                        WindowManager.getDefault().getMainWindow(),
                        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(
                            WindowManager.getDefault().getMainWindow(),
                            NbBundle.getMessage(Case.class, "Case.checkImgExist.confDlg.doesntExist.msg", appName, 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.getCaseMetadata().getFilePath().toString());

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

            /*
             * Reset the main window title to be [curent case display name] -
             * [application name], instead of just the application name.
             */
            addCaseNameToMainWindowTitle(newCurrentCase.getDisplayName());
        });
    }

    /*
     * Update the GUI to to reflect the lack of a current case.
     */
    private static void updateGUIForCaseClosed() {
        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].
             */
            Frame mainWindow = WindowManager.getDefault().getMainWindow();
            mainWindow.setTitle(appName);
        });
    }

    private static void addCaseNameToMainWindowTitle(String caseName) {
        if (!caseName.isEmpty()) {
            Frame frame = WindowManager.getDefault().getMainWindow();
            frame.setTitle(caseName + " - " + appName);
        }
    }

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

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

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

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

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

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

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

    public String getOutputDirectory() {
        String caseDirectory = getCaseDirectory();
        Path hostPath;
        if (getCaseMetadata().getCaseType() == CaseType.MULTI_USER_CASE) {
            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 void setTextIndexName(String textIndexName) throws CaseMetadataException {
        getCaseMetadata().setTextIndexName(textIndexName);
    }

    public String getTextIndexName() {
        return getCaseMetadata().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 getCaseMetadata() {
        return caseMetadata;
    }

    void updateCaseName(String oldCaseName, String oldPath, String newCaseName, String newPath) throws CaseActionException {
        try {
            caseMetadata.setCaseDisplayName(newCaseName);
            eventPublisher.publish(new AutopsyEvent(Events.NAME.toString(), oldCaseName, newCaseName));
            SwingUtilities.invokeLater(() -> {
                try {
                    RecentCases.getInstance().updateRecentCase(oldCaseName, oldPath, newCaseName, newPath);
                    addCaseNameToMainWindowTitle(newCaseName);

                } catch (Exception ex) {
                    Logger.getLogger(Case.class
                            .getName()).log(Level.SEVERE, "Error updating case name in UI", ex); //NON-NLS
                }
            });
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.updateCaseName.exception.msg"), ex);
        }
    }

    private Case() {
    }

    @Messages({
        "Case.progressIndicatorTitle.creatingCase=Creating Case",
        "Case.progressIndicatorCancelButton.label=Cancel",
        "Case.progressMessage.preparing=Preparing...",
        "Case.progressMessage.openingCaseResources=<html>Preparing to open case resources.<br>This may take time if another user is upgrading the case.</html>"
    })
    private void create(CaseType caseType, String caseDir, String caseDisplayName, String caseNumber, String examiner) throws CaseActionException {
        /*
         * Set up either a GUI progress indicator or a logging progress
         * indicator.
         */
        final CancelButtonListener listener = new CancelButtonListener();
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator = new ModalDialogProgressIndicator(
                    mainFrame,
                    Bundle.Case_progressIndicatorTitle_creatingCase(),
                    new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                    Bundle.Case_progressIndicatorCancelButton_label(),
                    listener);
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());

        /*
         * Creating a case is always done in the same non-UI thread that will be
         * used later to close 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.
         */
        caseLockingExecutor = Executors.newSingleThreadExecutor();
        Future<Void> future = caseLockingExecutor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == caseType) {
                create(caseType, caseDir, caseDisplayName, caseNumber, examiner, progressIndicator);
            } else {
                /*
                 * 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.
                 */
                progressIndicator.start(Bundle.Case_progressMessage_openingCaseResources());
                acquireSharedCaseDirLock(caseDir);

                /*
                 * Acquire an exclusive case resources lock to ensure only one
                 * node at a time can create/open/upgrade/close the case
                 * resources.
                 */
                try (CoordinationService.Lock resourcesLock = acquireExclusiveCaseResourcesLock(caseDir)) {
                    assert (null != resourcesLock);
                    try {
                        create(caseType, caseDir, caseDisplayName, caseNumber, examiner, progressIndicator);
                    } catch (CaseActionException ex) {
                        /*
                         * Release the case directory lock immediately if there
                         * was a problem opening the case.
                         */
                        if (CaseType.MULTI_USER_CASE == caseType) {
                            releaseSharedCaseDirLock(caseDir);
                        }
                        throw ex;
                    }
                }
            }
            return null;
        });

        /*
         * If running with a GUI, give the future for the case creation task to
         * the cancel button listener for the GUI progress indicator and make
         * the progress indicator visible to the user.
         */
        if (RuntimeProperties.runningWithGUI()) {
            listener.setCaseActionFuture(future);
            SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(true));
        }

        /*
         * Wait for the case creation task to finish.
         */
        try {
            future.get();
        } catch (InterruptedException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getMessage()), ex);
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getCause().getMessage()), ex);
        } catch (CancellationException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_cancelled(), ex);
        } finally {
            if (RuntimeProperties.runningWithGUI()) {
                SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(false));
            }
        }
    }

    @Messages({
        "Case.exceptionMessage.emptyCaseName=Case name is empty.",
        "Case.progressMessage.creatingCaseDirectory=Creating case directory...",
        "Case.progressMessage.creatingCaseDatabase=Creating case database...",
        "Case.exceptionMessage.couldNotCreateCaseDatabaseName=Failed to create case database name from case name.",
        "Case.progressMessage.creatingCaseMetadataFile=Creating case metadata file...",
        "Case.exceptionMessage.couldNotCreateMetadataFile=Failed to create case metadata file.",
        "Case.exceptionMessage.couldNotCreateCaseDatabase=Failed to create case database."
    })
    private void create(CaseType caseType, String caseDir, String caseDisplayName, String caseNumber, String examiner, ProgressIndicator progressIndicator) throws CaseActionException {
        /*
         * Create a unique and immutable case name from the case display name.
         */
        if (caseDisplayName.isEmpty()) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_emptyCaseName());            
        }
        String caseName = displayNameToUniqueName(caseDisplayName);

        /*
         * Create the case directory, if it does not already exist.
         *
         * TODO (JIRA-2180): The reason for this check for the existence of the
         * case directory is not at all obvious. It reflects the assumption that
         * if the case directory already exists, it is because the case is being
         * created using the the "New Case" wizard, which separates the creation
         * of the case directory from the creation of the case, with the idea
         * that if the case directory cannot be created, the user can be asked
         * to supply a different case directory path. This of course creates
         * subtle and undetectable coupling between this code and the wizard
         * code. The desired effect could be accomplished more simply and safely
         * by having this method throw a specific exception to indicate that the
         * case directory could not be created. In fact, a FEW specific
         * exception types would in turn allow us to put localized,
         * user-friendly messages in the GUI instead of putting user-friendly,
         * localized messages in the exceptions, which causes them to appear in
         * the application log, where it would be better to use English for
         * readability by the broadest group of developers.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDirectory());
        if (new File(caseDir).exists() == false) {
            Case.createCaseDirectory(caseDir, caseType);
        }

        /*
         * Create the case database.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseDatabase());
        String dbName = null;
        try {
            if (CaseType.SINGLE_USER_CASE == caseType) {
                /*
                 * For single-user cases, the case database is a SQLite database
                 * with a standard name, physically located in the root of the
                 * case directory.
                 */
                dbName = SINGLE_USER_CASE_DB_NAME;
                this.caseDb = SleuthkitCase.newCase(Paths.get(caseDir, SINGLE_USER_CASE_DB_NAME).toString());
            } else if (CaseType.MULTI_USER_CASE == caseType) {
                /*
                 * For multi-user cases, the case database is a PostgreSQL
                 * database with a name derived from the case display name,
                 * physically located on the database server.
                 */
                this.caseDb = SleuthkitCase.newCase(caseDisplayName, UserPreferences.getDatabaseConnectionInfo(), caseDir);
                dbName = this.caseDb.getDatabaseName();
            }
        } catch (TskCoreException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateCaseDatabase(), ex);
        } catch (UserPreferencesException ex) {
            throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.databaseConnectionInfo.error.msg"), ex);
        }

        /*
         * Create the case metadata (.aut) file.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_creatingCaseMetadataFile());
        try {
            this.caseMetadata = new CaseMetadata(caseDir, caseType, caseName, caseDisplayName, caseNumber, examiner, dbName);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotCreateMetadataFile(), ex);
        }

        openServices(progressIndicator);
    }

    private void open(Path caseMetadataFilePath) throws CaseActionException {
        /*
         * Read the contents of the case metadata file.
         */
        try {
            caseMetadata = new CaseMetadata(caseMetadataFilePath);
        } catch (CaseMetadataException ex) {
            throw new CaseActionException(Bundle.Case_openException_couldNotOpenCase(Bundle.Case_exceptionMessage_failedToReadMetadata()), ex);
        }

        /*
         * Set up either a GUI progress indicator or a logging progress
         * indicator.
         */
        CancelButtonListener listener = new CancelButtonListener();
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator = new ModalDialogProgressIndicator(
                    mainFrame,
                    Bundle.Case_progressIndicatorTitle_openingCase(),
                    new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                    Bundle.Case_progressIndicatorCancelButton_label(),
                    listener);
        } else {
            progressIndicator = new LoggingProgressIndicator();
        }
        progressIndicator.start(Bundle.Case_progressMessage_preparing());

        /*
         * Opening the case in the same thread that will be used later to close
         * 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.
         */
        CaseType caseType = caseMetadata.getCaseType();
        String caseName = caseMetadata.getCaseName();
        progressIndicator.start(Bundle.Case_progressMessage_preparing());
        caseLockingExecutor = Executors.newSingleThreadExecutor();
        Future<Void> future = caseLockingExecutor.submit(() -> {
            if (CaseType.SINGLE_USER_CASE == caseType) {
                openCaseDatabase(progressIndicator);
                openServices(progressIndicator);
            } else {
                /*
                 * First, acquire a shared case directory lock that will be held
                 * as long as this node has this case open, in order to prevent
                 * deletion of the case by another node.
                 */
                progressIndicator.start(Bundle.Case_progressMessage_openingCaseResources());
                acquireSharedCaseDirLock(caseMetadata.getCaseDirectory());
                /*
                 * Next, acquire an exclusive case resources lock to ensure only
                 * one node at a time can create/open/upgrade/close case
                 * resources.
                 */
                try (CoordinationService.Lock resourcesLock = acquireExclusiveCaseResourcesLock(caseMetadata.getCaseDirectory())) {
                    assert (null != resourcesLock);
                    try {
                        openCaseDatabase(progressIndicator);
                        openServices(progressIndicator);
                    } catch (CaseActionException ex) {
                        /*
                         * Release the case directory lock immediately if there
                         * was a problem opening the case.
                         */
                        if (CaseType.MULTI_USER_CASE == caseType) {
                            releaseSharedCaseDirLock(caseName);
                        }
                        throw ex;
                    }
                }
            }
            return null;
        });

        /*
         * If running with a GUI, give the future for the case opening task to
         * the cancel button listener for the GUI progress indicator and make
         * the progress indicator visible to the user.
         */
        if (RuntimeProperties.runningWithGUI()) {
            listener.setCaseActionFuture(future);
            SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(true));
        }

        /*
         * Wait for the case opening task to finish.
         */
        try {
            future.get();

        } catch (InterruptedException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getMessage()), ex);
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getCause().getMessage()), ex);
        } catch (CancellationException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_cancelled(), ex);
        } finally {
            if (RuntimeProperties.runningWithGUI()) {
                SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(false));
            }
        }
    }

    @Messages({
        "Case.progressMessage.openingCaseDatabase=Opening case database...",
        "Case.exceptionMessage.couldNotOpenCaseDatabase=Failed to open case database."
    })
    private void openCaseDatabase(ProgressIndicator progressIndicator) throws CaseActionException {
        /*
         * Open the case database.
         */
        try {
            progressIndicator.progress(Bundle.Case_progressMessage_openingCaseDatabase());
            if (CaseType.SINGLE_USER_CASE == caseMetadata.getCaseType()) {
                this.caseDb = SleuthkitCase.openCase(Paths.get(caseMetadata.getCaseDirectory(), caseMetadata.getCaseDatabaseName()).toString());
            } else if (UserPreferences.getIsMultiUserModeEnabled()) {
                try {
                    this.caseDb = SleuthkitCase.openCase(caseMetadata.getCaseDatabaseName(), UserPreferences.getDatabaseConnectionInfo(), caseMetadata.getCaseDirectory());

                } catch (UserPreferencesException ex) {
                    throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.databaseConnectionInfo.error.msg"), ex);

                }
            } else {
                throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.open.exception.multiUserCaseNotEnabled"));
            }
        } catch (TskCoreException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_couldNotOpenCaseDatabase(), ex);
        }
    }

    @Messages({
        "Case.progressMessage.switchingLogDirectory=Switching log directory...",
        "Case.progressMessage.settingUpTskErrorReporting=Setting up SleuthKit error reporting...",
        "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());

        /*
         * Hook up a SleuthKit layer error reporter.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_settingUpTskErrorReporting());
        this.sleuthkitErrorReporter = new SleuthkitErrorReporter(MIN_SECS_BETWEEN_TSK_ERROR_REPORTS, NbBundle.getMessage(Case.class, "IntervalErrorReport.ErrorText"));
        this.caseDb.addErrorObserver(this.sleuthkitErrorReporter);

        /*
         * Clear the temp subdirectory of the case directory.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_clearingTempDirectory());
        Case.clearTempSubDir(this.getTempDirectory());

        /*
         * Open the case-level services.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_openingCaseLevelServices());
        this.caseServices = new Services(this.caseDb);

        /*
         * Allow any registered application services to open any resources
         * specific to this case.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_openingApplicationServiceResources());
        openAppServiceCaseResources();

        /*
         * If this case is a multi-user case, set up for communication with
         * other nodes.
         */
        if (CaseType.MULTI_USER_CASE == this.caseMetadata.getCaseType()) {
            progressIndicator.progress(Bundle.Case_progressMessage_settingUpNetworkCommunications());
            try {
                eventPublisher.openRemoteEventChannel(String.format(EVENT_CHANNEL_NAME, this.getName()));
                collaborationMonitor = new CollaborationMonitor(this.getName());
            } 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.servicesException.notificationTitle={0} Error",
        "# {0} - service name", "Case.servicesException.serviceResourcesOpenCancelled=Opening case resources for {0} cancelled",
        "# {0} - service name", "# {1} - exception message", "Case.servicesException.serviceResourcesOpenError=Could not open case resources for {0} service: {1}"
    })
    private void openAppServiceCaseResources() throws CaseActionException {
        /*
         * Each service gets its own independently cancellable task, and thus
         * its own task progress indicator.
         */
        ExecutorService executor = Executors.newSingleThreadExecutor();

        for (AutopsyService service : Lookup.getDefault().lookupAll(AutopsyService.class)) {
            CancelButtonListener buttonListener = new CancelButtonListener();
            ProgressIndicator progressIndicator;
            if (RuntimeProperties.runningWithGUI()) {
                progressIndicator = new ModalDialogProgressIndicator(
                        mainFrame,
                        Bundle.Case_serviceOpenCaseResourcesProgressIndicator_title(service.getServiceName()),
                        new String[]{Bundle.Case_progressIndicatorCancelButton_label()},
                        Bundle.Case_progressIndicatorCancelButton_label(),
                        buttonListener);
            } else {
                progressIndicator = new LoggingProgressIndicator();
            }
            progressIndicator.start(Bundle.Case_progressMessage_preparing());

            AutopsyService.CaseContext context = new AutopsyService.CaseContext(this, progressIndicator);
            if (RuntimeProperties.runningWithGUI()) {
                buttonListener.setCaseContext(context);
            }
            Future<Void> future = executor.submit(() -> {
                service.openCaseResources(context);
                return null;
            });
            if (RuntimeProperties.runningWithGUI()) {
                buttonListener.setCaseActionFuture(future);
                SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(true));
            }
            try {
                future.get();
            } catch (InterruptedException ex) {
                Case.logger.log(Level.SEVERE, String.format("Unexpected interrupt while waiting on %s service to open case resources", service.getServiceName()), ex);

            } catch (CancellationException ex) {
                /*
                 * 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.WARNING, String.format("%s service opening of case resources cancelled", service.getServiceName()));
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> MessageNotifyUtil.Notify.warn(
                            Bundle.Case_servicesException_notificationTitle(service.getServiceName()),
                            Bundle.Case_servicesException_serviceResourcesOpenCancelled(service.getServiceName())));
                }
            } catch (ExecutionException ex) {
                /*
                 * 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 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_serviceResourcesOpenError(service.getServiceName(), ex.getLocalizedMessage())));
                }
            } finally {
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(false));
                }
            }
        }
        /*
         * No tasks left, simply shut down the executor.
         */
        executor.shutdown();
    }

    @Messages({
        "Case.progressMessage.closingCaseResources=<html>Preparing to close case resources.<br>This may take time if another user is upgrading the case.</html>",
        "Case.progressMessage.notifyingCaseEventSubscribers=Notifying case event subscribers...",
        "Case.progressMessage.clearingTempDirectory=Clearing case temp directory...",
        "Case.progressMessage.closingCaseLevelServices=Closing case-level services...",
        "Case.progressMessage.closingApplicationServiceResources=Closing case-specific application service resources...",
        "Case.progressMessage.tearingDownNetworkCommunications=Tearing down network communications...",
        "Case.progressMessage.closingCaseDatabase=Closing case database...",
        "Case.progressMessage.tearingDownTskErrorReporting=Tearing down SleuthKit error reporting..."
    })
    private void close() throws CaseActionException {
        /*
         * Set up either a GUI progress indicator or a logging progress
         * indicator.
         */
        ProgressIndicator progressIndicator;
        if (RuntimeProperties.runningWithGUI()) {
            progressIndicator = new ModalDialogProgressIndicator(
                    Case.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 == caseMetadata.getCaseType()) {
                close(progressIndicator);
            } else {
                String caseName = caseMetadata.getCaseName();
                /*
                 * Acquire an exclusive case resources lock to ensure only one
                 * node at a time can create/open/upgrade/close the case
                 * resources.
                 */
                progressIndicator.start(Bundle.Case_progressMessage_closingCaseResources());
                try (CoordinationService.Lock resourcesLock = acquireExclusiveCaseResourcesLock(caseMetadata.getCaseDirectory())) {
                    assert (null != resourcesLock);
                    close(progressIndicator);
                } finally {
                    /*
                     * Always release the case directory lock that was acquired
                     * when the case was opened.
                     */
                    releaseSharedCaseDirLock(caseName);
                }
            }
            return null;
        });

        /*
         * If running with a GUI, give the future for the case closing task to
         * the cancel button listener for the GUI progress indicator and make
         * the progress indicator visible to the user.
         */
        if (RuntimeProperties.runningWithGUI()) {
            SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(true));
        }

        try {
            logger.log(Level.INFO, "Closing case with metadata file path {0}", getCaseMetadata().getFilePath()); //NON-NLS
            future.get();
        } catch (InterruptedException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getMessage()), ex);
        } catch (ExecutionException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_wrapperMessage(ex.getCause().getMessage()), ex);
        } catch (CancellationException ex) {
            throw new CaseActionException(Bundle.Case_exceptionMessage_cancelled(), ex);
        } finally {
            caseLockingExecutor.shutdown();
            if (RuntimeProperties.runningWithGUI()) {
                SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(false));
            }
        }
    }

    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 == caseMetadata.getCaseType()) {
            progressIndicator.progress(Bundle.Case_progressMessage_tearingDownNetworkCommunications());
            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.
         */
        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
         */
        progressIndicator.progress(Bundle.Case_progressMessage_closingCaseDatabase());
        caseDb.close();

        /*
         * Disconnect the SleuthKit layer error reporter.
         */
        progressIndicator.progress(Bundle.Case_progressMessage_tearingDownTskErrorReporting());
        caseDb.removeErrorObserver(sleuthkitErrorReporter);

        /*
         * 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.
         */
        ExecutorService executor = Executors.newSingleThreadExecutor();

        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);
            Future<Void> future = executor.submit(() -> {
                service.closeCaseResources(context);
                return null;
            });
            if (RuntimeProperties.runningWithGUI()) {
                SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(true));
            }
            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 {
                if (RuntimeProperties.runningWithGUI()) {
                    SwingUtilities.invokeLater(() -> ((ModalDialogProgressIndicator) progressIndicator).setVisible(false));
                }
            }
        }
        /*
         * No tasks left, simply shut down the executor.
         */
        executor.shutdown();
    }

    @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 final static class CancelButtonListener implements ActionListener {

        private Future<?> caseActionFuture;
        private CaseContext caseContext;

        private void setCaseActionFuture(Future<?> caseActionFuture) {
            this.caseActionFuture = caseActionFuture;
        }

        private void setCaseContext(CaseContext caseContext) {
            this.caseContext = caseContext;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (null != this.caseContext) {
                this.caseContext.requestCancel();
            }
            if (null != this.caseActionFuture) {
                this.caseActionFuture.cancel(true);
            }
        }

    }

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

}