IngestMonitor.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 * 
 * Copyright 2012 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.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.SimpleFormatter;

import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.coreutils.Logger;
import javax.swing.Timer;
import org.openide.util.Exceptions;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.PlatformUtil;

public final class IngestMonitor {

    public static final int DISK_FREE_SPACE_UNKNOWN = -1;
    private static final int INITIAL_INTERVAL_MS = 60000; //1 min.
    private final Logger logger = Logger.getLogger(IngestMonitor.class.getName());
    private Timer timer;
    private static final java.util.logging.Logger MONITOR_LOGGER = java.util.logging.Logger.getLogger("monitor"); //NON-NLS
    private MonitorAction monitor;

    IngestMonitor() {

        //setup the custom memory logger
        try {
            final int MAX_LOG_FILES = 3;
            FileHandler monitorLogHandler = new FileHandler(PlatformUtil.getUserDirectory().getAbsolutePath() + "/var/log/monitor.log", //NON-NLS
                    0, MAX_LOG_FILES);
            monitorLogHandler.setFormatter(new SimpleFormatter());
            monitorLogHandler.setEncoding(PlatformUtil.getLogFileEncoding());
            MONITOR_LOGGER.addHandler(monitorLogHandler);
            //do not forward to the parent autopsy logger
            MONITOR_LOGGER.setUseParentHandlers(false);
        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        } catch (SecurityException ex) {
            Exceptions.printStackTrace(ex);
        }

    }

    void start() {
        monitor = new MonitorAction();
        timer = new Timer(INITIAL_INTERVAL_MS, monitor);
        timer.start();
    }

    void stop() {
        if (timer != null) {
            timer.stop();
        }
    }

    boolean isRunning() {
        return timer != null && timer.isRunning();
    }

    long getFreeSpace() {
        try {
            return monitor.getFreeSpace();
        } catch (SecurityException e) {
            logger.log(Level.WARNING, "Error checking for free disk space on ingest data drive", e); //NON-NLS
            return DISK_FREE_SPACE_UNKNOWN;
        }
    }

    //TODO add support to monitor multiple drives, e.g. user dir drive in addition to Case drive
    private class MonitorAction implements ActionListener {

        private final static long MIN_FREE_DISK_SPACE = 100L * 1024 * 1024; //100MB
        private File root = new File(File.separator); //default, root dir where autopsy runs

        MonitorAction() {
            //find drive where case is located
            setMonitorDir();

            //update monitor dir if case changed
            Case.addPropertyChangeListener(new PropertyChangeListener() {
                @Override
                public void propertyChange(PropertyChangeEvent evt) {
                    String changed = evt.getPropertyName();
                    Object newValue = evt.getNewValue();

                    if (changed.equals(Case.Events.CURRENT_CASE.toString())) {
                        if (newValue != null) {
                            setMonitorDir();
                        }

                    }


                }
            });

        }

        private void setMonitorDir() {
            String caseDir = Case.getCurrentCase().getCaseDirectory();
            File curDir = new File(caseDir);
            File tempF = null;
            while ((tempF = curDir.getParentFile()) != null) {
                curDir = tempF;
            }
            root = curDir;
            logger.log(Level.INFO, "Monitoring disk space of case root: " + curDir.getAbsolutePath()); //NON-NLS
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            final IngestManager manager = IngestManager.getInstance();

            //runs checks only if ingest is running
            if (manager.isIngestRunning() == false) {
                return;
            }

            monitorMemory();

            if (checkDiskSpace() == false) {
                //stop ingest if running
                final String diskPath = root.getAbsolutePath();
                MONITOR_LOGGER.log(Level.SEVERE, "Stopping ingest due to low disk space on disk {0}", diskPath); //NON-NLS
                logger.log(Level.SEVERE, "Stopping ingest due to low disk space on disk {0}", diskPath); //NON-NLS
                manager.cancelAllIngestJobs();
                IngestServices.getInstance().postMessage(IngestMessage.createManagerErrorMessage(
                        NbBundle.getMessage(this.getClass(), "IngestMonitor.mgrErrMsg.lowDiskSpace.title", diskPath),
                        NbBundle.getMessage(this.getClass(), "IngestMonitor.mgrErrMsg.lowDiskSpace.msg", diskPath)));
            }
        }

        private long getFreeSpace() throws SecurityException {
            final long freeSpace = root.getFreeSpace();

            if (freeSpace == 0) {
                //check if network drive, some network filesystems always return 0
                final String monitoredPath = root.getAbsolutePath();
                if (monitoredPath.startsWith("\\\\") || monitoredPath.startsWith("//")) {
                    return DISK_FREE_SPACE_UNKNOWN;

                }
            }

            return freeSpace;

        }

        private boolean checkDiskSpace() {
            long freeSpace;
            try {
                freeSpace = getFreeSpace();
            } catch (SecurityException e) {
                logger.log(Level.WARNING, "Unable to check for free disk space (permission issue)", e); //NON-NLS
                return true; //OK
            }

            if (freeSpace == DISK_FREE_SPACE_UNKNOWN) {
                return true;
            } else {
                //logger.log(Level.INFO, "Checking free disk apce: " + freeSpace + " need: " + Long.toString(MIN_FREE_DISK_SPACE));
                return freeSpace > MIN_FREE_DISK_SPACE;
            }
        }

        private void monitorMemory() {
            MONITOR_LOGGER.log(Level.INFO, PlatformUtil.getAllMemUsageInfo());
        }
    }
}