ServicesMonitor.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2013-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.core;

import org.sleuthkit.autopsy.core.events.ServiceEvent;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.beans.PropertyChangeListener;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.MessageNotifyUtil;
import org.sleuthkit.autopsy.events.AutopsyEventPublisher;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchService;
import org.sleuthkit.autopsy.events.MessageServiceConnectionInfo;
import org.sleuthkit.autopsy.events.MessageServiceException;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchServiceException;
import org.sleuthkit.datamodel.CaseDbConnectionInfo;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;

public class ServicesMonitor {

    private AutopsyEventPublisher eventPublisher;
    private static final Logger logger = Logger.getLogger(ServicesMonitor.class.getName());
    private final ScheduledThreadPoolExecutor periodicTasksExecutor;

    private static final String PERIODIC_TASK_THREAD_NAME = "services-monitor-periodic-task-%d"; //NON-NLS
    private static final int NUMBER_OF_PERIODIC_TASK_THREADS = 1;
    private static final long CRASH_DETECTION_INTERVAL_MINUTES = 2;

    private static final Set<String> servicesList = Stream.of(ServicesMonitor.Service.values())
            .map(Service::toString)
            .collect(Collectors.toSet());

    private final ConcurrentHashMap<String, String> statusByService;

    private static ServicesMonitor instance = new ServicesMonitor();

    public enum Service {

        REMOTE_CASE_DATABASE(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.remoteCaseDatabase.displayName.text")),
        REMOTE_KEYWORD_SEARCH(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.remoteKeywordSearch.displayName.text")),
        MESSAGING(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.messaging.displayName.text"));

        private final String displayName;

        private Service(String name) {
            this.displayName = name;
        }

        public String getDisplayName() {
            return displayName;
        }
    };

    public enum ServiceStatus {

        UP,
        DOWN
    };

    public synchronized static ServicesMonitor getInstance() {
        if (instance == null) {
            instance = new ServicesMonitor();
        }
        return instance;
    }

    private ServicesMonitor() {

        this.eventPublisher = new AutopsyEventPublisher();
        this.statusByService = new ConcurrentHashMap<>();

        // First check is triggered immediately on current thread.
        checkAllServices();

        periodicTasksExecutor = new ScheduledThreadPoolExecutor(NUMBER_OF_PERIODIC_TASK_THREADS, new ThreadFactoryBuilder().setNameFormat(PERIODIC_TASK_THREAD_NAME).build());
        periodicTasksExecutor.scheduleAtFixedRate(new CrashDetectionTask(), CRASH_DETECTION_INTERVAL_MINUTES, CRASH_DETECTION_INTERVAL_MINUTES, TimeUnit.MINUTES);
    }

    public void setServiceStatus(String service, String status, String details) {
        // if the status update is for an existing service who's status hasn't changed - do nothing.       
        if (statusByService.containsKey(service) && status.equals(statusByService.get(service))) {
            return;
        }

        // new service or status has changed - identify service's display name
        String serviceDisplayName;
        try {
            serviceDisplayName = ServicesMonitor.Service.valueOf(service).getDisplayName();
        } catch (IllegalArgumentException ignore) {
            // custom service that is not listed in ServicesMonitor.Service enum. Use service name as display name.
            serviceDisplayName = service;
        }

        if (status.equals(ServiceStatus.UP.toString())) {
            logger.log(Level.INFO, "Connection to {0} is up", serviceDisplayName); //NON-NLS
            MessageNotifyUtil.Notify.info(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.restoredService.notify.title"),
                    NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.restoredService.notify.msg", serviceDisplayName));
        } else if (status.equals(ServiceStatus.DOWN.toString())) {
            logger.log(Level.SEVERE, "Failed to connect to {0}. Reason: {1}", new Object[]{serviceDisplayName, details}); //NON-NLS
            MessageNotifyUtil.Notify.error(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.failedService.notify.title"),
                    NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.failedService.notify.msg", serviceDisplayName));
        } else {
            logger.log(Level.INFO, "Status for {0} is {1}", new Object[]{serviceDisplayName, status}); //NON-NLS
            MessageNotifyUtil.Notify.info(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.statusChange.notify.title"),
                    NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.statusChange.notify.msg", new Object[]{serviceDisplayName, status}));
        }

        // update and publish new status
        statusByService.put(service, status);
        eventPublisher.publishLocally(new ServiceEvent(service, status, details));
    }

    public String getServiceStatus(String service) throws ServicesMonitorException {

        if (service == null) {
            throw new ServicesMonitorException(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.nullServiceName.excepton.txt"));
        }

        // if request is for one of our "core" services - perform an on demand check
        // to make sure we have the latest status.
        if (servicesList.contains(service)) {
            checkServiceStatus(service);
        }

        String status = statusByService.get(service);
        if (status == null) {
            // no such service
            throw new ServicesMonitorException(NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.unknownServiceName.excepton.txt", service));
        }
        return status;
    }

    private void checkServiceStatus(String service) {
        if (service.equals(Service.REMOTE_CASE_DATABASE.toString())) {
            checkDatabaseConnectionStatus();
        } else if (service.equals(Service.REMOTE_KEYWORD_SEARCH.toString())) {
            checkKeywordSearchServerConnectionStatus();
        } else if (service.equals(Service.MESSAGING.toString())) {
            checkMessagingServerConnectionStatus();
        }
    }

    private void checkDatabaseConnectionStatus() {
        CaseDbConnectionInfo info;
        try {
            info = UserPreferences.getDatabaseConnectionInfo();
        } catch (UserPreferencesException ex) {
            logger.log(Level.SEVERE, "Error accessing case database connection info", ex); //NON-NLS
            setServiceStatus(Service.REMOTE_CASE_DATABASE.toString(), ServiceStatus.DOWN.toString(), NbBundle.getMessage(this.getClass(), "ServicesMonitor.databaseConnectionInfo.error.msg"));
            return;
        }
        try {
            SleuthkitCase.tryConnect(info);
            setServiceStatus(Service.REMOTE_CASE_DATABASE.toString(), ServiceStatus.UP.toString(), "");
        } catch (TskCoreException ex) {
            setServiceStatus(Service.REMOTE_CASE_DATABASE.toString(), ServiceStatus.DOWN.toString(), ex.getMessage());
        }
    }

    private void checkKeywordSearchServerConnectionStatus() {
        KeywordSearchService kwsService = Lookup.getDefault().lookup(KeywordSearchService.class);
        try {
            if (kwsService != null) {
                int port = Integer.parseUnsignedInt(UserPreferences.getIndexingServerPort());
                kwsService.tryConnect(UserPreferences.getIndexingServerHost(), port);
                setServiceStatus(Service.REMOTE_KEYWORD_SEARCH.toString(), ServiceStatus.UP.toString(), "");
            } else {
                setServiceStatus(Service.REMOTE_KEYWORD_SEARCH.toString(), ServiceStatus.DOWN.toString(),
                        NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.KeywordSearchNull"));
            }
        } catch (NumberFormatException ex) {
            String rootCause = NbBundle.getMessage(ServicesMonitor.class, "ServicesMonitor.InvalidPortNumber");
            logger.log(Level.SEVERE, "Unable to connect to messaging server: " + rootCause, ex); //NON-NLS
            setServiceStatus(Service.REMOTE_KEYWORD_SEARCH.toString(), ServiceStatus.DOWN.toString(), rootCause);
        } catch (KeywordSearchServiceException ex) {
            String rootCause = ex.getMessage();
            logger.log(Level.SEVERE, "Unable to connect to messaging server: " + rootCause, ex); //NON-NLS
            setServiceStatus(Service.REMOTE_KEYWORD_SEARCH.toString(), ServiceStatus.DOWN.toString(), rootCause);
        }
    }

    private void checkMessagingServerConnectionStatus() {
        MessageServiceConnectionInfo info;
        try {
            info = UserPreferences.getMessageServiceConnectionInfo();
        } catch (UserPreferencesException ex) {
            logger.log(Level.SEVERE, "Error accessing messaging service connection info", ex); //NON-NLS
            setServiceStatus(Service.MESSAGING.toString(), ServiceStatus.DOWN.toString(), NbBundle.getMessage(this.getClass(), "ServicesMonitor.messagingService.connErr.text"));
            return;
        }

        try {
            info.tryConnect();
            setServiceStatus(Service.MESSAGING.toString(), ServiceStatus.UP.toString(), "");
        } catch (MessageServiceException ex) {
            String rootCause = ex.getMessage();
            logger.log(Level.SEVERE, "Unable to connect to messaging server: " + rootCause, ex); //NON-NLS
            setServiceStatus(Service.MESSAGING.toString(), ServiceStatus.DOWN.toString(), rootCause);
        }
    }

    public void addSubscriber(PropertyChangeListener subscriber) {
        eventPublisher.addSubscriber(servicesList, subscriber);
    }

    public void addSubscriber(Set<String> eventNames, PropertyChangeListener subscriber) {
        eventPublisher.addSubscriber(eventNames, subscriber);
    }

    public void addSubscriber(String eventName, PropertyChangeListener subscriber) {
        eventPublisher.addSubscriber(eventName, subscriber);
    }

    public void removeSubscriber(Set<String> eventNames, PropertyChangeListener subscriber) {
        eventPublisher.removeSubscriber(eventNames, subscriber);
    }

    public void removeSubscriber(String eventName, PropertyChangeListener subscriber) {
        eventPublisher.removeSubscriber(eventName, subscriber);
    }

    public void removeSubscriber(PropertyChangeListener subscriber) {
        eventPublisher.removeSubscriber(servicesList, subscriber);
    }

    private void checkAllServices() {
        if (!UserPreferences.getIsMultiUserModeEnabled()) {
            return;
        }

        for (String service : servicesList) {
            checkServiceStatus(service);
        }
    }

    private final class CrashDetectionTask implements Runnable {

        @Override
        public void run() {
            try {
                checkAllServices();
            } catch (Exception ex) {
                logger.log(Level.SEVERE, "Unexpected exception in CrashDetectionTask", ex); //NON-NLS
            }
        }
    }

    public class ServicesMonitorException extends Exception {

        private static final long serialVersionUID = 1L;

        public ServicesMonitorException(String message) {
            super(message);
        }

        public ServicesMonitorException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}