ImageWriterService.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2016 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.imagewriter;

import java.util.ArrayList;
import java.util.List;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.util.NbBundle;
import org.openide.util.lookup.ServiceProvider;
import org.openide.util.lookup.ServiceProviders;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.framework.AutopsyService;

@ServiceProviders(value = {@ServiceProvider(service = AutopsyService.class)})

public class ImageWriterService implements AutopsyService {

    private static final List<ImageWriter> imageWriters = new ArrayList<>();  // Contains all Image Writer objects
    private static final Object imageWritersLock = new Object(); // Get this lock before accessing currentImageWriters    
    
    public static void createImageWriter(Long imageId, ImageWriterSettings settings){
        
        // ImageWriter objects are created during the addImageTask. They can not arrive while
        // we're closing case resources so we don't need to worry about one showing up while
        // doing our close/cleanup.
        synchronized(imageWritersLock){
            ImageWriter writer = new ImageWriter(imageId, settings);
            writer.subscribeToEvents();
            imageWriters.add(writer);
        }
    }
    
    @Override
    public String getServiceName() {
        return NbBundle.getMessage(this.getClass(), "ImageWriterService.serviceName");
    }
    
    @Override
    public void closeCaseResources(CaseContext context) throws AutopsyServiceException {
        context.getProgressIndicator().progress(NbBundle.getMessage(this.getClass(), "ImageWriterService.waitingForVHDs"));
        
        synchronized(imageWritersLock){
            // If any of our ImageWriter objects haven't started the finish task, set the cancel flag
            // to make sure they don't start now. The reason they haven't started is that
            // ingest was not complete, and the user already confirmed that they want to exit
            // even though ingest is not complete so we will take that to mean that they
            // also don't want to wait for Image Writer.
            for(ImageWriter writer: imageWriters){
                writer.cancelIfNotStarted();
            }
            
            // Test whether any finishImage tasks are in progress
            boolean jobsAreInProgress = false;
            for(ImageWriter writer: imageWriters){
                if(writer.jobIsInProgress()){
                    jobsAreInProgress = true;
                    break;
                }
            }
            
            if(jobsAreInProgress){
                // If jobs are in progress, ask the user if they want to wait for them to complete
                NotifyDescriptor descriptor = new NotifyDescriptor.Confirmation(
                    NbBundle.getMessage(this.getClass(), "ImageWriterService.shouldWait"),
                    NbBundle.getMessage(this.getClass(), "ImageWriterService.localDisk"),
                    NotifyDescriptor.YES_NO_OPTION,
                    NotifyDescriptor.WARNING_MESSAGE);
                descriptor.setValue(NotifyDescriptor.NO_OPTION);
                Object response = DialogDisplayer.getDefault().notify(descriptor);
                
                if(response == DialogDescriptor.NO_OPTION){
                    // Cancel all the jobs
                    for(ImageWriter writer: imageWriters){
                        writer.cancelJob();
                    }
                }
                
                // Wait for all finishImage jobs to complete. If the jobs got cancelled
                // this will be very fast.
                for(ImageWriter writer: imageWriters){
                    writer.waitForJobToFinish();
                }
                
            }
            
            // Stop listening for events
            for(ImageWriter writer: imageWriters){
                writer.unsubscribeFromEvents();
            }
            
            // Clear out the list of Image Writers
            imageWriters.clear();
        }
    }
}