be_process_forkmanager.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_PROCESS_FORKMANAGER_H__
#define __BE_PROCESS_FORKMANAGER_H__
 
#include <unistd.h>
 
#include <list>
 
#include <be_process_manager.h>
 
namespace BiometricEvaluation
{
        namespace Process
        {
                /* Forward declaration */
                class ForkWorkerController;
 
                class ForkManager : public Manager
                {
                public:
                        static std::list<ForkManager*> FORKMANAGERS;
 
                        ForkManager();
 
                        std::shared_ptr<WorkerController>
                        addWorker(
                            std::shared_ptr<Worker> worker);
 
                        void
                        startWorkers(
                            bool wait = true,
                            bool communicate = false);
   
                        void
                        startWorker(
                            std::shared_ptr<WorkerController> worker,
                            bool wait = true,
                            bool communicate = false);
 
                        void
                        stopWorker(
                            std::shared_ptr<WorkerController> workerController);
 
                        void broadcastSignal(int signo);
 
                        bool
                        responsibleFor(
                            const pid_t pid)
                            const;
 
                        void
                        setNotWorking(
                            const pid_t pid);
 
                        void
                        markAllFinished();
 
                        bool
                        getIsWorkingStatus(
                            const pid_t pid)
                            const;
 
                        void
                        waitForWorkerExit();
 
                        ~ForkManager();
 
                        void
                        setExitCallback(
                            void (*exitCallback)
                            (std::shared_ptr<ForkWorkerController> worker,
                            int stat_loc));
 
                        static void
                        defaultExitCallback(
                            std::shared_ptr<ForkWorkerController> worker,
                            int status);
 
                        void
                        setExitStatus(
                            const pid_t pid,
                            const int32_t waitStatus);
                        
                private:
                        std::shared_ptr<ForkWorkerController>
                        getProcessWithPID(
                            pid_t pid);
 
                        void
                        _wait();
 
                        static void
                        reap(
                            int signal);
 
                        class Status {
                        public:
                                Status();
 
                                pid_t pid;
                                bool isWorking;
                        };
                            
                        void
                        (*_exitCallback)
                            (std::shared_ptr<ForkWorkerController> wc,
                            int stat_loc);
                
                        bool _parent;
 
                        std::map<
                            std::shared_ptr<ForkWorkerController>, Status>
                            _wcStatus;
                };
                
                
                class ForkWorkerController : public WorkerController
                {
                public:
                        bool
                        isWorking()
                            const;
 
                        bool
                        everWorked()
                            const;
                            
                        void
                        reset();
 
                        pid_t
                        getPID()
                            const;
                        
                        static void
                        _stop(
                            int signal);
 
                        ~ForkWorkerController();
                        
                protected:
                
                private:
                
                        ForkWorkerController(
                            std::shared_ptr<Worker> worker);
                            
                        void
                        start(
                            bool communicate = false);
 
                        void
                        stop();
 
                        pid_t _pid;
                        
                        static std::shared_ptr<Worker> _staticWorker;
 
                        /*
                         * Friends.
                         */
                        
                        friend void
                        ForkManager::startWorkers(
                            bool wait,
                            bool communicate);
 
                        friend void
                        ForkManager::startWorker(
                            std::shared_ptr<WorkerController> worker,
                            bool wait,
                            bool communicate);
 
                        friend void
                        ForkManager::stopWorker(
                            std::shared_ptr<WorkerController> workerController);
 
                        friend std::shared_ptr<WorkerController>
                        ForkManager::addWorker(
                            std::shared_ptr<Worker> worker);
 
                        friend void
                        ForkManager::setExitStatus(
                            const pid_t pid,
                            const int32_t waitStatus);
                };
        }
}
 
#endif /* __BE_PROCESS_FORKMANAGER_H__ */