Process.cc

Go to the documentation of this file.

/*
 * Process.cc
 *
 * Smalltalk like class library for C++
 * Process wrapper.
 *
 * Copyright (c) 2004 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <stlib/os/Process.h>
#include <stlib/Array.h>
#include <stlib/FileAccessor.h>
#include <stlib/Iterator.h>
#include <stlib/Set.h>
#include <stlib/String.h>

using namespace OS;

bool Process::has_handler = false;
Set Process::processes(5);         // Process container

Process::Process(void)
{
    finalizeProcesses();
    _receiver = nil;
    _arguments = nil;
    // Nastavime priznak beziciho vlakna
    runningProcess = false;
    process_id = 0;
    _status = 0;
}

Process::Process(Callback<void> *receiver, Array *args)
{
    finalizeProcesses();
    // Nastavime vykonnou funkci
    _receiver = receiver;
    _arguments = args;
    // Nastavime priznak beziciho vlakna
    runningProcess = false;
    process_id = 0;
    _status = 0;
}

Process::~Process(void)
{
//    terminate();
}

Process *Process::fork(Callback<void> *receiver)
{
    Process *process = new Process(receiver);
    process->run();
    return process;
}

Process *Process::fork(Callback<void> *receiver, Array *args)
{
    Process *process = new Process(receiver, args);
    process->run();
    return process;
}

Process *Process::forkJob(String *progName, SequenceableCollection *args,
                          SequenceableCollection *fds)
{
    Callback1<Process,void,Array*> *callback;
    Array *funcArgs = Array::with(progName, args, fds);
    Process *process = new Process;

    callback = new Callback1<Process,void,Array*>(process, &Process::privateExecuteJob);
    process->receiver(callback);
    process->arguments(funcArgs);
    process->run();
    return process;
}

/* Accessing protocol */
void Process::arguments(Array *args)
{
    _arguments = args;
}

void Process::receiver(Callback<void> *obj)
{
    _receiver = obj;
}

int Process::status(void)
{
    return _status;
}

/* Prevezme hodnoty od ukoncenych procesu */
void Process::finalizeProcesses(void)
{
    Set *temp = (Set *) processes.copy();
    for (Iterator* i = temp->iterator(); !i->finished(); i->next()) {
        Process *p = (Process *) i->value();
        if (!p->isRunning())
            p->finalize();
    }
    delete temp;
}

// obnovi beh procesu
void Process::resume()
{
    if (runningProcess == false) {  // vlakno dosud nebylo vytvoreno
        // zadna akce
        return;
    }
    kill(process_id, SIGCONT);
}

// pozastavi beh procesu
void Process::suspend()
{
    if (runningProcess == false) {  // vlakno dosud nebylo vytvoreno
        // zadna akce
        return;
    }
    kill(process_id, SIGSTOP);
}

void Process::run()
{
    int pid;
    if (_receiver == nil) return;  // Not fully initialized

    if ((pid = ::fork()) == 0) {
        /* I'm child */
        runningProcess = true;
        _receiver->executeWith(_arguments);
        exit(0);
    } else {
        /* I'm parent */
        if (pid == -1) { // fork failed
            // Better to raise an Exception here
            return;
        }
        runningProcess = true;
        process_id = pid;
        processes.add(this);
        if (!has_handler) {
            struct sigaction handler;
            handler.sa_handler = Process::sigchildHandler;
            handler.sa_flags = SA_NOCLDSTOP;
            sigaction(SIGCHLD, &handler, NULL);
            has_handler = true;
        }
    }
}

void Process::finalize(void)
{
    processes.remove(this);
}

void Process::terminate(void)
{
    // zruseni vlakna
    if (runningProcess != false) {
        kill(process_id, SIGTERM);
        // Pockame az vlakno dobehne a odchytime navratovou hodnotu
        finalize();
    }
}

void Process::yield(void)
{
    /* nothing
       - there is no way to force another process to leave the processor */
}

/* Testing protocol */
bool Process::isRunning(void)
{
    return runningProcess;
}

/* Private protocol */
void Process::childSignaled(void)
{
    int pid;
    pid = waitpid(process_id, &_status, WNOHANG);
    if (pid > 0) {
        runningProcess = false;
        finalize();
    }
}

void Process::privateExecuteJob(Array *args)
{
    String *progName = (String *) args->at(0);
    SequenceableCollection *progArgs = (SequenceableCollection *) args->at(1);
    SequenceableCollection *fds = (SequenceableCollection *) args->at(2);

    char *file = progName->asCString();
    char *fileArgs[progArgs->size() + 2];
    fileArgs[0] = file;
    for (int i = 0; i < progArgs->size(); i++)
        fileArgs[i+1] = dynamic_cast<String *>(progArgs->at(i))->asCString();
    fileArgs[progArgs->size() + 1] = NULL;
    /* file descriptors assignment */
    if (fds != nil) {
        FileAccessor *fd = dynamic_cast<FileAccessor *>(fds->at(0));
        if (fd != nil) {
            close(0);   // stdin
            fd->changeDescriptorTo(0);
        }
        fd = dynamic_cast<FileAccessor *>(fds->at(1));
        if (fd != nil) {
            close(1);   // stdout
            fd->changeDescriptorTo(1);
        }
        fd = dynamic_cast<FileAccessor *>(fds->at(2));
        if (fd != nil) {
            close(2);   // stderr
            fd->changeDescriptorTo(2);
        }
    }
    execvp(file, fileArgs);
}

void Process::sigchildHandler(int signum)
{
    Set *temp = (Set *) processes.copy();
    for (Iterator* i = temp->iterator(); !i->finished(); i->next()) {
        Process *p = (Process *) i->value();
        p->childSignaled();
    }
    delete temp;
}

---