IngestTasksScheduler.java

Go to the documentation of this file.

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

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.TreeSet;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.AnalysisResult;
import org.sleuthkit.datamodel.Blackboard;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.DataArtifact;
import org.sleuthkit.datamodel.DataSource;
import org.sleuthkit.datamodel.FileSystem;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskData;

@ThreadSafe
final class IngestTasksScheduler {

    private static final int FAT_NTFS_FLAGS = TskData.TSK_FS_TYPE_ENUM.TSK_FS_TYPE_FAT12.getValue() | TskData.TSK_FS_TYPE_ENUM.TSK_FS_TYPE_FAT16.getValue() | TskData.TSK_FS_TYPE_ENUM.TSK_FS_TYPE_FAT32.getValue() | TskData.TSK_FS_TYPE_ENUM.TSK_FS_TYPE_NTFS.getValue();
    private static final Logger logger = Logger.getLogger(IngestTasksScheduler.class.getName());
    @GuardedBy("IngestTasksScheduler.this")
    private static IngestTasksScheduler instance;
    private final IngestTaskTrackingQueue dataSourceIngestTasksQueue;
    @GuardedBy("this")
    private final TreeSet<FileIngestTask> topLevelFileIngestTasksQueue;
    @GuardedBy("this")
    private final Deque<FileIngestTask> batchedFileIngestTasksQueue;
    @GuardedBy("this")
    private final Queue<FileIngestTask> streamedFileIngestTasksQueue;
    private final IngestTaskTrackingQueue fileIngestTasksQueue;
    private final IngestTaskTrackingQueue artifactIngestTasksQueue;
    private final IngestTaskTrackingQueue resultIngestTasksQueue;

    synchronized static IngestTasksScheduler getInstance() {
        if (IngestTasksScheduler.instance == null) {
            IngestTasksScheduler.instance = new IngestTasksScheduler();
        }
        return IngestTasksScheduler.instance;
    }

    private IngestTasksScheduler() {
        dataSourceIngestTasksQueue = new IngestTaskTrackingQueue();
        topLevelFileIngestTasksQueue = new TreeSet<>(new RootDirectoryTaskComparator());
        batchedFileIngestTasksQueue = new LinkedList<>();
        fileIngestTasksQueue = new IngestTaskTrackingQueue();
        streamedFileIngestTasksQueue = new LinkedList<>();
        artifactIngestTasksQueue = new IngestTaskTrackingQueue();
        resultIngestTasksQueue = new IngestTaskTrackingQueue();
    }

    BlockingIngestTaskQueue getDataSourceIngestTaskQueue() {
        return dataSourceIngestTasksQueue;
    }

    BlockingIngestTaskQueue getFileIngestTaskQueue() {
        return fileIngestTasksQueue;
    }

    BlockingIngestTaskQueue getDataArtifactIngestTaskQueue() {
        return artifactIngestTasksQueue;
    }

    BlockingIngestTaskQueue getAnalysisResultIngestTaskQueue() {
        return resultIngestTasksQueue;
    }

    synchronized void scheduleDataSourceIngestTask(IngestJobExecutor executor) {
        if (!executor.isCancelled()) {
            DataSourceIngestTask task = new DataSourceIngestTask(executor);
            try {
                dataSourceIngestTasksQueue.putLast(task);
            } catch (InterruptedException ex) {
                IngestTasksScheduler.logger.log(Level.INFO, String.format("Ingest tasks scheduler interrupted while blocked adding a task to the data source level ingest task queue (ingest job ID={%d)", executor.getIngestJobId()), ex);
                Thread.currentThread().interrupt();
            }
        }
    }

    synchronized void scheduleFileIngestTasks(IngestJobExecutor executor, Collection<AbstractFile> files) {
        if (!executor.isCancelled()) {
            Collection<AbstractFile> candidateFiles;
            if (files.isEmpty()) {
                candidateFiles = getTopLevelFiles(executor.getDataSource());
            } else {
                candidateFiles = files;
            }
            for (AbstractFile file : candidateFiles) {
                FileIngestTask task = new FileIngestTask(executor, file);
                if (IngestTasksScheduler.shouldEnqueueFileTask(task)) {
                    topLevelFileIngestTasksQueue.add(task);
                }
            }
            refillFileIngestTasksQueue();
        }
    }

    synchronized void scheduleStreamedFileIngestTasks(IngestJobExecutor executor, List<Long> fileIds) {
        if (!executor.isCancelled()) {
            for (long id : fileIds) {
                /*
                 * Create the file ingest task. Note that we do not do the
                 * shouldEnqueueFileTask() check here in order to delay querying
                 * the case database to construct the AbstractFile object. The
                 * file filter will be applied before the file task makes it to
                 * the task queue consumed by the file ingest threads.
                 */
                FileIngestTask task = new FileIngestTask(executor, id);
                streamedFileIngestTasksQueue.add(task);
            }
            refillFileIngestTasksQueue();
        }
    }

    synchronized void scheduleHighPriorityFileIngestTasks(IngestJobExecutor executor, Collection<AbstractFile> files) {
        if (!executor.isCancelled()) {
            /*
             * Put the files directly into the queue for the file ingest
             * threads, if they pass the file filter for the job. The files are
             * added to the queue for the ingest threads BEFORE the other queued
             * tasks because the use case for this method is scheduling new
             * carved or derived files from a high priority task that is already
             * in progress.
             */
            for (AbstractFile file : files) {
                FileIngestTask fileTask = new FileIngestTask(executor, file);
                if (shouldEnqueueFileTask(fileTask)) {
                    try {
                        fileIngestTasksQueue.putFirst(fileTask);
                    } catch (InterruptedException ex) {
                        DataSource dataSource = executor.getDataSource();
                        logger.log(Level.WARNING, String.format("Interrupted while enqueuing file tasks for %s (data source object ID = %d)", dataSource.getName(), dataSource.getId()), ex); //NON-NLS
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }
        }
    }

    synchronized void scheduleDataArtifactIngestTasks(IngestJobExecutor executor) {
        if (!executor.isCancelled()) {
            Blackboard blackboard = Case.getCurrentCase().getSleuthkitCase().getBlackboard();
            try {
                List<DataArtifact> artifacts = blackboard.getDataArtifacts(executor.getDataSource().getId(), null);
                scheduleDataArtifactIngestTasks(executor, artifacts);
            } catch (TskCoreException ex) {
                DataSource dataSource = executor.getDataSource();
                logger.log(Level.SEVERE, String.format("Failed to retrieve data artifacts for %s (data source object ID = %d)", dataSource.getName(), dataSource.getId()), ex); //NON-NLS
            }
        }
    }

    synchronized void scheduleAnalysisResultIngestTasks(IngestJobExecutor executor) {
        if (!executor.isCancelled()) {
            Blackboard blackboard = Case.getCurrentCase().getSleuthkitCase().getBlackboard();
            try {
                List<AnalysisResult> results = blackboard.getAnalysisResults(executor.getDataSource().getId(), null);
                scheduleAnalysisResultIngestTasks(executor, results);
            } catch (TskCoreException ex) {
                DataSource dataSource = executor.getDataSource();
                logger.log(Level.SEVERE, String.format("Failed to retrieve analysis results for %s (data source object ID = %d)", dataSource.getName(), dataSource.getId()), ex); //NON-NLS
            }
        }
    }

    synchronized void scheduleDataArtifactIngestTasks(IngestJobExecutor executor, List<DataArtifact> artifacts) {
        if (!executor.isCancelled()) {
            for (DataArtifact artifact : artifacts) {
                DataArtifactIngestTask task = new DataArtifactIngestTask(executor, artifact);
                try {
                    artifactIngestTasksQueue.putLast(task);
                } catch (InterruptedException ex) {
                    DataSource dataSource = executor.getDataSource();
                    logger.log(Level.WARNING, String.format("Interrupted while enqueuing data artifact tasks for %s (data source object ID = %d)", dataSource.getName(), dataSource.getId()), ex); //NON-NLS
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
    }

    synchronized void scheduleAnalysisResultIngestTasks(IngestJobExecutor executor, List<AnalysisResult> results) {
        if (!executor.isCancelled()) {
            for (AnalysisResult result : results) {
                AnalysisResultIngestTask task = new AnalysisResultIngestTask(executor, result);
                try {
                    resultIngestTasksQueue.putLast(task);
                } catch (InterruptedException ex) {
                    DataSource dataSource = executor.getDataSource();
                    logger.log(Level.WARNING, String.format("Interrupted while enqueuing analysis results tasks for %s (data source object ID = %d)", dataSource.getName(), dataSource.getId()), ex); //NON-NLS
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
    }

    synchronized void notifyTaskCompleted(DataSourceIngestTask task) {
        dataSourceIngestTasksQueue.taskCompleted(task);
    }

    synchronized void notifyTaskCompleted(FileIngestTask task) {
        fileIngestTasksQueue.taskCompleted(task);
        refillFileIngestTasksQueue();
    }

    synchronized void notifyTaskCompleted(DataArtifactIngestTask task) {
        artifactIngestTasksQueue.taskCompleted(task);
    }

    synchronized void notifyTaskCompleted(AnalysisResultIngestTask task) {
        resultIngestTasksQueue.taskCompleted(task);
    }

    synchronized boolean currentTasksAreCompleted(Long ingestJobId) {
        return !(dataSourceIngestTasksQueue.hasTasksForJob(ingestJobId)
                || hasTasksForJob(topLevelFileIngestTasksQueue, ingestJobId)
                || hasTasksForJob(batchedFileIngestTasksQueue, ingestJobId)
                || hasTasksForJob(streamedFileIngestTasksQueue, ingestJobId)
                || fileIngestTasksQueue.hasTasksForJob(ingestJobId)
                || artifactIngestTasksQueue.hasTasksForJob(ingestJobId)
                || resultIngestTasksQueue.hasTasksForJob(ingestJobId));
    }

    synchronized void cancelPendingFileTasksForIngestJob(long ingestJobId) {
        removeTasksForJob(topLevelFileIngestTasksQueue, ingestJobId);
        removeTasksForJob(batchedFileIngestTasksQueue, ingestJobId);
        removeTasksForJob(streamedFileIngestTasksQueue, ingestJobId);
    }

    private static List<AbstractFile> getTopLevelFiles(Content dataSource) {
        List<AbstractFile> topLevelFiles = new ArrayList<>();
        Collection<AbstractFile> rootObjects = dataSource.accept(new GetRootDirectoryVisitor());
        if (rootObjects.isEmpty() && dataSource instanceof AbstractFile) {
            /*
             * The data source is itself a file to be processed.
             */
            topLevelFiles.add((AbstractFile) dataSource);
        } else {
            for (AbstractFile root : rootObjects) {
                List<Content> children;
                try {
                    children = root.getChildren();
                    if (children.isEmpty()) {
                        /*
                         * Add the root object itself, it could be an
                         * unallocated space file, or a child of a volume or an
                         * image.
                         */
                        topLevelFiles.add(root);
                    } else {
                        /*
                         * The root object is a file system root directory, get
                         * the files within it.
                         */
                        for (Content child : children) {
                            if (child instanceof AbstractFile) {
                                topLevelFiles.add((AbstractFile) child);
                            }
                        }
                    }
                } catch (TskCoreException ex) {
                    logger.log(Level.SEVERE, "Could not get children of root to enqueue: " + root.getId() + ": " + root.getName(), ex); //NON-NLS
                }
            }
        }
        return topLevelFiles;
    }

    synchronized private void refillFileIngestTasksQueue() {
        try {
            takeFromStreamingFileTasksQueue();
            takeFromBatchTasksQueues();
        } catch (InterruptedException ex) {
            IngestTasksScheduler.logger.log(Level.INFO, "Ingest tasks scheduler interrupted while blocked adding a task to the file level ingest task queue", ex);
            Thread.currentThread().interrupt();
        }
    }

    synchronized private void takeFromStreamingFileTasksQueue() throws InterruptedException {
        while (fileIngestTasksQueue.isEmpty()) {
            int taskCount = 0;
            while (taskCount < IngestManager.getInstance().getNumberOfFileIngestThreads()) {
                final FileIngestTask streamingTask = streamedFileIngestTasksQueue.poll();
                if (streamingTask == null) {
                    return; // No streaming tasks are queued right now
                }
                if (shouldEnqueueFileTask(streamingTask)) {
                    fileIngestTasksQueue.putLast(streamingTask);
                    taskCount++;
                }
            }
        }
    }

    synchronized private void takeFromBatchTasksQueues() throws InterruptedException {

        while (fileIngestTasksQueue.isEmpty()) {
            /*
             * If the batched file task queue is empty, move the highest
             * priority top level file task into it.
             */
            if (batchedFileIngestTasksQueue.isEmpty()) {
                final FileIngestTask topLevelTask = topLevelFileIngestTasksQueue.pollFirst();
                if (topLevelTask != null) {
                    batchedFileIngestTasksQueue.addLast(topLevelTask);
                }
            }

            /*
             * Try to move the next task from the batched file tasks queue into
             * the queue for the file ingest threads.
             */
            final FileIngestTask nextTask = batchedFileIngestTasksQueue.pollFirst();
            if (nextTask == null) {
                return;
            }
            if (shouldEnqueueFileTask(nextTask)) {
                fileIngestTasksQueue.putLast(nextTask);
            }

            /*
             * If the task that was just queued for the file ingest threads has
             * children, queue tasks for the children as well.
             */
            AbstractFile file = null;
            try {
                file = nextTask.getFile();
                List<Content> children = file.getChildren();
                for (Content child : children) {
                    if (child instanceof AbstractFile) {
                        AbstractFile childFile = (AbstractFile) child;
                        FileIngestTask childTask = new FileIngestTask(nextTask.getIngestJobExecutor(), childFile);
                        if (childFile.hasChildren()) {
                            batchedFileIngestTasksQueue.add(childTask);
                        } else if (shouldEnqueueFileTask(childTask)) {
                            fileIngestTasksQueue.putLast(childTask);
                        }
                    }
                }
            } catch (TskCoreException ex) {
                if (file != null) {
                    logger.log(Level.SEVERE, String.format("Error getting the children of %s (object ID = %d)", file.getName(), file.getId()), ex); //NON-NLS
                } else {
                    logger.log(Level.SEVERE, "Error loading file with object ID = {0}", nextTask.getFileId()); //NON-NLS
                }
            }
        }
    }

    private static boolean shouldEnqueueFileTask(final FileIngestTask task) {
        AbstractFile file;
        try {
            file = task.getFile();
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, "Error loading file with ID {0}", task.getFileId());
            return false;
        }

        /*
         * Skip the task if the file is actually the pseudo-file for the parent
         * or current directory.
         */
        String fileName = file.getName();

        if (fileName.equals(".") || fileName.equals("..")) {
            return false;
        }

        /*
         * Ensures that all directories, files which are members of the ingest
         * file filter, and unallocated blocks (when processUnallocated is
         * enabled) all continue to be processed. AbstractFiles which do not
         * meet one of these criteria will be skipped.
         *
         * An additional check to see if unallocated space should be processed
         * is part of the FilesSet.fileIsMemberOf() method.
         *
         * This code may need to be updated when
         * TSK_DB_FILES_TYPE_ENUM.UNUSED_BLOCKS comes into use by Autopsy.
         */
        if (!file.isDir() && !shouldBeCarved(task) && !fileAcceptedByFilter(task)) {
            return false;
        }

        /*
         * Skip the task if the file is one of a select group of special, large
         * NTFS or FAT file system files.
         */
        if (file instanceof org.sleuthkit.datamodel.File) {
            final org.sleuthkit.datamodel.File f = (org.sleuthkit.datamodel.File) file;

            /*
             * Get the type of the file system, if any, that owns the file.
             */
            TskData.TSK_FS_TYPE_ENUM fsType = TskData.TSK_FS_TYPE_ENUM.TSK_FS_TYPE_UNSUPP;
            try {
                FileSystem fs = f.getFileSystem();
                if (fs != null) {
                    fsType = fs.getFsType();
                }
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, "Error querying file system for " + f, ex); //NON-NLS
            }

            /*
             * If the file system is not NTFS or FAT, don't skip the file.
             */
            if ((fsType.getValue() & FAT_NTFS_FLAGS) == 0) {
                return true;
            }

            /*
             * Find out whether the file is in a root directory.
             */
            boolean isInRootDir = false;
            try {
                AbstractFile parent = f.getParentDirectory();
                if (parent == null) {
                    isInRootDir = true;
                } else {
                    isInRootDir = parent.isRoot();
                }
            } catch (TskCoreException ex) {
                logger.log(Level.WARNING, "Error querying parent directory for" + f.getName(), ex); //NON-NLS
            }

            /*
             * If the file is in the root directory of an NTFS or FAT file
             * system, check its meta-address and check its name for the '$'
             * character and a ':' character (not a default attribute).
             */
            if (isInRootDir && f.getMetaAddr() < 32) {
                String name = f.getName();
                if (name.length() > 0 && name.charAt(0) == '$' && name.contains(":")) {
                    return false;
                }
            }
        }

        return true;
    }

    private static boolean shouldBeCarved(final FileIngestTask task) {
        try {
            AbstractFile file = task.getFile();
            return task.getIngestJobExecutor().shouldProcessUnallocatedSpace() && file.getType().equals(TskData.TSK_DB_FILES_TYPE_ENUM.UNALLOC_BLOCKS);
        } catch (TskCoreException ex) {
            return false;
        }
    }

    private static boolean fileAcceptedByFilter(final FileIngestTask task) {
        try {
            AbstractFile file = task.getFile();
            return !(task.getIngestJobExecutor().getFileIngestFilter().fileIsMemberOf(file) == null);
        } catch (TskCoreException ex) {
            return false;
        }
    }

    synchronized private static boolean hasTasksForJob(Collection<? extends IngestTask> tasks, long ingestJobId) {
        for (IngestTask task : tasks) {
            if (task.getIngestJobExecutor().getIngestJobId() == ingestJobId) {
                return true;
            }
        }
        return false;
    }

    private static void removeTasksForJob(Collection<? extends IngestTask> tasks, long ingestJobId) {
        Iterator<? extends IngestTask> iterator = tasks.iterator();
        while (iterator.hasNext()) {
            IngestTask task = iterator.next();
            if (task.getIngestJobExecutor().getIngestJobId() == ingestJobId) {
                iterator.remove();
            }
        }
    }

    private static int countTasksForJob(Collection<? extends IngestTask> tasks, long ingestJobId) {
        int count = 0;
        for (IngestTask task : tasks) {
            if (task.getIngestJobExecutor().getIngestJobId() == ingestJobId) {
                count++;
            }
        }
        return count;
    }

    synchronized IngestTasksSnapshot getTasksSnapshotForJob(long ingestJobId) {
        return new IngestTasksSnapshot(
                ingestJobId,
                dataSourceIngestTasksQueue.countQueuedTasksForJob(ingestJobId),
                countTasksForJob(topLevelFileIngestTasksQueue, ingestJobId),
                countTasksForJob(batchedFileIngestTasksQueue, ingestJobId),
                fileIngestTasksQueue.countQueuedTasksForJob(ingestJobId),
                countTasksForJob(streamedFileIngestTasksQueue, ingestJobId),
                artifactIngestTasksQueue.countQueuedTasksForJob(ingestJobId),
                resultIngestTasksQueue.countQueuedTasksForJob(ingestJobId),
                dataSourceIngestTasksQueue.countRunningTasksForJob(ingestJobId) + fileIngestTasksQueue.countRunningTasksForJob(ingestJobId) + artifactIngestTasksQueue.countRunningTasksForJob(ingestJobId) + resultIngestTasksQueue.countRunningTasksForJob(ingestJobId)
        );
    }

    private static class RootDirectoryTaskComparator implements Comparator<FileIngestTask> {

        @Override
        public int compare(FileIngestTask q1, FileIngestTask q2) {
            /*
             * In practice the case where one or both calls to getFile() fails
             * should never occur since such tasks would not be added to the
             * queue.
             */
            AbstractFile file1 = null;
            AbstractFile file2 = null;
            try {
                file1 = q1.getFile();
            } catch (TskCoreException ex) {
                /*
                 * Do nothing - the exception has been logged elsewhere
                 */
            }

            try {
                file2 = q2.getFile();
            } catch (TskCoreException ex) {
                /*
                 * Do nothing - the exception has been logged elsewhere
                 */
            }

            if (file1 == null) {
                if (file2 == null) {
                    return (int) (q2.getFileId() - q1.getFileId());
                } else {
                    return 1;
                }
            } else if (file2 == null) {
                return -1;
            }

            AbstractFilePriority.Priority p1 = AbstractFilePriority.getPriority(file1);
            AbstractFilePriority.Priority p2 = AbstractFilePriority.getPriority(file2);
            if (p1 == p2) {
                return (int) (file2.getId() - file1.getId());
            } else {
                return p2.ordinal() - p1.ordinal();
            }
        }

        private static class AbstractFilePriority {

            private AbstractFilePriority() {
            }

            enum Priority {

                LAST, LOW, MEDIUM, HIGH
            }

            static final List<Pattern> LAST_PRI_PATHS = new ArrayList<>();

            static final List<Pattern> LOW_PRI_PATHS = new ArrayList<>();

            static final List<Pattern> MEDIUM_PRI_PATHS = new ArrayList<>();

            static final List<Pattern> HIGH_PRI_PATHS = new ArrayList<>();

            /*
             * Prioritize root directory folders based on the assumption that we
             * are looking for user content. Other types of investigations may
             * want different priorities.
             */
            static {
                // these files have no structure, so they go last
                //unalloc files are handled as virtual files in getPriority()
                //LAST_PRI_PATHS.schedule(Pattern.compile("^\\$Unalloc", Pattern.CASE_INSENSITIVE));
                //LAST_PRI_PATHS.schedule(Pattern.compile("^\\Unalloc", Pattern.CASE_INSENSITIVE));
                LAST_PRI_PATHS.add(Pattern.compile("^pagefile", Pattern.CASE_INSENSITIVE));
                LAST_PRI_PATHS.add(Pattern.compile("^hiberfil", Pattern.CASE_INSENSITIVE));
                // orphan files are often corrupt and windows does not typically have
                // user content, so put them towards the bottom
                LOW_PRI_PATHS.add(Pattern.compile("^\\$OrphanFiles", Pattern.CASE_INSENSITIVE));
                LOW_PRI_PATHS.add(Pattern.compile("^Windows", Pattern.CASE_INSENSITIVE));
                // all other files go into the medium category too
                MEDIUM_PRI_PATHS.add(Pattern.compile("^Program Files", Pattern.CASE_INSENSITIVE));
                // user content is top priority
                HIGH_PRI_PATHS.add(Pattern.compile("^Users", Pattern.CASE_INSENSITIVE));
                HIGH_PRI_PATHS.add(Pattern.compile("^Documents and Settings", Pattern.CASE_INSENSITIVE));
                HIGH_PRI_PATHS.add(Pattern.compile("^home", Pattern.CASE_INSENSITIVE));
                HIGH_PRI_PATHS.add(Pattern.compile("^ProgramData", Pattern.CASE_INSENSITIVE));
            }

            static AbstractFilePriority.Priority getPriority(final AbstractFile abstractFile) {
                if (!abstractFile.getType().equals(TskData.TSK_DB_FILES_TYPE_ENUM.FS)) {
                    //quickly filter out unstructured content
                    //non-fs virtual files and dirs, such as representing unalloc space
                    return AbstractFilePriority.Priority.LAST;
                }
                //determine the fs files priority by name
                final String path = abstractFile.getName();
                if (path == null) {
                    return AbstractFilePriority.Priority.MEDIUM;
                }
                for (Pattern p : HIGH_PRI_PATHS) {
                    Matcher m = p.matcher(path);
                    if (m.find()) {
                        return AbstractFilePriority.Priority.HIGH;
                    }
                }
                for (Pattern p : MEDIUM_PRI_PATHS) {
                    Matcher m = p.matcher(path);
                    if (m.find()) {
                        return AbstractFilePriority.Priority.MEDIUM;
                    }
                }
                for (Pattern p : LOW_PRI_PATHS) {
                    Matcher m = p.matcher(path);
                    if (m.find()) {
                        return AbstractFilePriority.Priority.LOW;
                    }
                }
                for (Pattern p : LAST_PRI_PATHS) {
                    Matcher m = p.matcher(path);
                    if (m.find()) {
                        return AbstractFilePriority.Priority.LAST;
                    }
                }
                //default is medium
                return AbstractFilePriority.Priority.MEDIUM;
            }
        }
    }

    @ThreadSafe
    private class IngestTaskTrackingQueue implements BlockingIngestTaskQueue {

        private final BlockingDeque<IngestTask> taskQueue = new LinkedBlockingDeque<>();
        @GuardedBy("this")
        private final List<IngestTask> queuedTasks = new LinkedList<>();
        @GuardedBy("this")
        private final List<IngestTask> tasksInProgress = new LinkedList<>();

        void putFirst(IngestTask task) throws InterruptedException {
            synchronized (this) {
                this.queuedTasks.add(task);
            }
            try {
                this.taskQueue.putFirst(task);
            } catch (InterruptedException ex) {
                synchronized (this) {
                    this.queuedTasks.remove(task);
                }
                throw ex;
            }
        }

        void putLast(IngestTask task) throws InterruptedException {
            synchronized (this) {
                this.queuedTasks.add(task);
            }
            try {
                this.taskQueue.putLast(task);
            } catch (InterruptedException ex) {
                synchronized (this) {
                    this.queuedTasks.remove(task);
                }
                throw ex;
            }
        }

        @Override
        public IngestTask getNextTask() throws InterruptedException {
            IngestTask task = taskQueue.takeFirst();
            synchronized (this) {
                this.queuedTasks.remove(task);
                this.tasksInProgress.add(task);
            }
            return task;
        }

        boolean isEmpty() {
            synchronized (this) {
                return this.queuedTasks.isEmpty();
            }
        }

        void taskCompleted(IngestTask task) {
            synchronized (this) {
                this.tasksInProgress.remove(task);
            }
        }

        boolean hasTasksForJob(long ingestJobId) {
            synchronized (this) {
                return IngestTasksScheduler.hasTasksForJob(queuedTasks, ingestJobId) || IngestTasksScheduler.hasTasksForJob(tasksInProgress, ingestJobId);
            }
        }

        int countQueuedTasksForJob(long ingestJobId) {
            synchronized (this) {
                return IngestTasksScheduler.countTasksForJob(queuedTasks, ingestJobId);
            }
        }

        int countRunningTasksForJob(long ingestJobId) {
            synchronized (this) {
                return IngestTasksScheduler.countTasksForJob(tasksInProgress, ingestJobId);
            }
        }

    }

    static final class IngestTasksSnapshot implements Serializable {

        private static final long serialVersionUID = 1L;
        private final long ingestJobId;
        private final long dataSourceQueueSize;
        private final long rootQueueSize;
        private final long dirQueueSize;
        private final long fileQueueSize;
        private final long inProgressListSize;
        private final long streamedFileQueueSize;
        private final long artifactsQueueSize;
        private final long resultsQueueSize;

        IngestTasksSnapshot(long ingestJobId, long dataSourceQueueSize, long rootQueueSize, long dirQueueSize, long fileQueueSize, long streamedFileQueueSize, long artifactsQueueSize, long resultsQueueSize, long inProgressListSize) {
            this.ingestJobId = ingestJobId;
            this.dataSourceQueueSize = dataSourceQueueSize;
            this.rootQueueSize = rootQueueSize;
            this.dirQueueSize = dirQueueSize;
            this.fileQueueSize = fileQueueSize;
            this.streamedFileQueueSize = streamedFileQueueSize;
            this.artifactsQueueSize = artifactsQueueSize;
            this.resultsQueueSize = resultsQueueSize;
            this.inProgressListSize = inProgressListSize;
        }

        long getIngestJobId() {
            return ingestJobId;
        }

        long getRootQueueSize() {
            return rootQueueSize;
        }

        long getDirQueueSize() {
            return dirQueueSize;
        }

        long getFileQueueSize() {
            return fileQueueSize;
        }

        long getStreamedFilesQueueSize() {
            return streamedFileQueueSize;
        }

        long getDataSourceQueueSize() {
            return dataSourceQueueSize;
        }

        long getArtifactsQueueSize() {
            return artifactsQueueSize;
        }

        long getResultsQueueSize() {
            return resultsQueueSize;
        }

        long getProgressListSize() {
            return inProgressListSize;
        }

    }

}