FileIngestPipeline.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 * 
 * Copyright 2014-2015 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.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;

import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.MessageNotifyUtil;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.TskCoreException;

final class FileIngestPipeline {

    private static final IngestManager ingestManager = IngestManager.getInstance();
    private final DataSourceIngestJob job;
    private final List<PipelineModule> modules = new ArrayList<>();
    private Date startTime;
    private volatile boolean running;

    FileIngestPipeline(DataSourceIngestJob job, List<IngestModuleTemplate> moduleTemplates) {
        this.job = job;
        for (IngestModuleTemplate template : moduleTemplates) {
            if (template.isFileIngestModuleTemplate()) {
                PipelineModule module = new PipelineModule(template.createFileIngestModule(), template.getModuleName());
                modules.add(module);
            }
        }
    }

    boolean isEmpty() {
        return this.modules.isEmpty();
    }

    boolean isRunning() {
        return this.running;
    }

    Date getStartTime() {
        return this.startTime;
    }

    synchronized List<IngestModuleError> startUp() {
        this.startTime = new Date();
        this.running = true;
        List<IngestModuleError> errors = new ArrayList<>();
        for (PipelineModule module : this.modules) {
            try {
                module.startUp(new IngestJobContext(this.job));
            } catch (Throwable ex) { // Catch-all exception firewall
                errors.add(new IngestModuleError(module.getDisplayName(), ex));
            }
        }
        return errors;
    }

    synchronized List<IngestModuleError> process(FileIngestTask task) {
        List<IngestModuleError> errors = new ArrayList<>();
        if (!this.job.isCancelled()) {
            AbstractFile file = task.getFile();
            for (PipelineModule module : this.modules) {
                try {
                    FileIngestPipeline.ingestManager.setIngestTaskProgress(task, module.getDisplayName());
                    this.job.setCurrentFileIngestModule(module.getDisplayName(), task.getFile().getName());
                    module.process(file);
                } catch (Throwable ex) { // Catch-all exception firewall
                    errors.add(new IngestModuleError(module.getDisplayName(), ex));
                }
                if (this.job.isCancelled()) {
                    break;
                }
            }
            
            if (!this.job.isCancelled()) {
                // Save any properties that have not already been saved to the database
                try{
                    file.save();
                } catch (TskCoreException ex){
                    Logger.getLogger(FileIngestPipeline.class.getName()).log(Level.SEVERE, "Failed to save data for file " + file.getId(), ex); //NON-NLS
                }
                IngestManager.getInstance().fireFileIngestDone(file);
            }
            file.close();
        }
        FileIngestPipeline.ingestManager.setIngestTaskProgressCompleted(task);
        return errors;
    }

    synchronized List<IngestModuleError> shutDown() {
        List<IngestModuleError> errors = new ArrayList<>();
        if (this.running == true) { // Don't shut down pipelines that never started
            for (PipelineModule module : this.modules) {
                try {
                    module.shutDown();
                } catch (Throwable ex) { // Catch-all exception firewall
                    errors.add(new IngestModuleError(module.getDisplayName(), ex));
                    String msg = ex.getMessage();
                    // Jython run-time errors don't seem to have a message, but have details in toString.
                    if (msg == null) {
                        msg = ex.toString();
                    }
                    MessageNotifyUtil.Notify.error(NbBundle.getMessage(this.getClass(), "FileIngestPipeline.moduleError.title.text", module.getDisplayName()), msg);
                }
            }
        }
        this.running = false;
        return errors;
    }

    private static final class PipelineModule implements FileIngestModule {

        private final FileIngestModule module;
        private final String displayName;

        PipelineModule(FileIngestModule module, String displayName) {
            this.module = module;
            this.displayName = displayName;
        }

        String getClassName() {
            return module.getClass().getCanonicalName();
        }

        String getDisplayName() {
            return displayName;
        }

        @Override
        public void startUp(IngestJobContext context) throws IngestModuleException {
            module.startUp(context);
        }

        @Override
        public IngestModule.ProcessResult process(AbstractFile file) {
            return module.process(file);
        }

        @Override
        public void shutDown() {
            module.shutDown();
        }

    }

}