FileTaskExecutor.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.modules.embeddedfileextractor;
 
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.sleuthkit.autopsy.apputils.ApplicationLoggers;
import java.util.logging.Logger;
import org.sleuthkit.autopsy.ingest.IngestJobContext;
import org.sleuthkit.autopsy.threadutils.TaskRetryUtil;

class FileTaskExecutor {
 
    private static final int MIN_THREADS_IN_POOL = 4;
    private static final int MAX_THREADS_IN_POOL = Integer.MAX_VALUE; // Effectively no limit
    private static final String FILE_IO_TASK_THREAD_NAME = "file-io-executor-task-%d";
    private static final String FILE_EXISTS_TASK_DESC_FMT_STR = "Checking if %s already exists";
    private static final String MKDIRS_TASK_DESC_FMT_STR = "Making directory %s";
    private static final String NEW_FILE_TASK_DESC_FMT_STR = "Creating new file %s";
    private static final String FILE_OPS_LOG_NAME = "efe_file_ops";
    private static final Logger logger = ApplicationLoggers.getLogger(FILE_OPS_LOG_NAME);
    private final ScheduledThreadPoolExecutor executor;
    private final TaskTerminator terminator;

    FileTaskExecutor(IngestJobContext context) {
        executor = new ScheduledThreadPoolExecutor(MIN_THREADS_IN_POOL, new ThreadFactoryBuilder().setNameFormat(FILE_IO_TASK_THREAD_NAME).build());
        executor.setMaximumPoolSize(MAX_THREADS_IN_POOL);
        if (context != null) {
            terminator = new TaskTerminator(context);
        } else {
            terminator = null;
        }
    }

    boolean exists(final File file) throws FileTaskFailedException, InterruptedException {
        Callable<Boolean> task = () -> {
            return file.exists();
        };
        return attemptTask(task, String.format(FILE_EXISTS_TASK_DESC_FMT_STR, file.getPath()));
    }

    boolean mkdirs(final File file) throws FileTaskFailedException, InterruptedException {
        Callable<Boolean> task = () -> {
            return file.mkdirs();
        };
        return attemptTask(task, String.format(MKDIRS_TASK_DESC_FMT_STR, file.getPath()));
    }

    boolean createNewFile(final File file) throws FileTaskFailedException, InterruptedException {
        Callable<Boolean> task = () -> {
            return file.createNewFile();
        };
        return attemptTask(task, String.format(NEW_FILE_TASK_DESC_FMT_STR, file.getPath()));
    }

    private boolean attemptTask(Callable<Boolean> task, String taskDesc) throws FileTaskFailedException, InterruptedException {
        List<TaskRetryUtil.TaskAttempt> attempts = new ArrayList<>();
        attempts.add(new TaskRetryUtil.TaskAttempt(0L, 10L, TimeUnit.MINUTES));
        attempts.add(new TaskRetryUtil.TaskAttempt(5L, 10L, TimeUnit.MINUTES));
        attempts.add(new TaskRetryUtil.TaskAttempt(10L, 10L, TimeUnit.MINUTES));
        attempts.add(new TaskRetryUtil.TaskAttempt(15L, 10L, TimeUnit.MINUTES));
        Boolean success = TaskRetryUtil.attemptTask(task, attempts, executor, terminator, logger, taskDesc);
        if (success == null) {
            throw new FileTaskFailedException(taskDesc + " failed");
        }
        return success;
    }

    void shutDown() {
        /*
         * Not waiting for task terminaton because some tasks may never
         * terminate. See class doc.
         */
        executor.shutdownNow();
    }

    private static class TaskTerminator implements TaskRetryUtil.Terminator {
 
        private final IngestJobContext context;

        TaskTerminator(IngestJobContext context) {
            this.context = context;
        }
 
        @Override
        public boolean stopTaskAttempts() {
            /*
             * This works because IngestJobContext.fileIngestIsCancelled() calls
             * IngestJobPipeline.isCancelled(), which returns the value of a
             * volatile variable.
             */
            return context.fileIngestIsCancelled();
        }
    }

    static final class FileTaskFailedException extends Exception {
 
        private static final long serialVersionUID = 1L;

        private FileTaskFailedException(String message) {
            super(message);
        }

        private FileTaskFailedException(String message, Throwable cause) {
            super(message, cause);
        }
    }
 
}