PDG_ServiceClient.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __PDG_SERVICE_CLIENT_H__
#define __PDG_SERVICE_CLIENT_H__

#include "PDG_API.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

class PDG_Scheduler;
class PDG_Service;

/*
 * Basic information about a service client and utilities for generating a 
 * client's command line string and spawning a client as a standalone
 * process
 */
class PDG_API PDG_ServiceClient
{
public:
    /// Constructs a new client info instance
                            PDG_ServiceClient(
                                const PDG_Service* service,
                                const UT_StringHolder& server_address,
                                int server_port,
                                int client_num);

    /// Constructs an incomplete client instance -- this is used for
    /// compatbility with older version of Houdini that did not
    /// explicitly track client info
                            PDG_ServiceClient(
                                const UT_StringHolder& client_name,
                                int client_num);

    /// Returns the command for the client as a string, but combining the
    /// command arguments 
    UT_StringHolder         commandString() const;


    /// Returns the current command line args for the service client
    inline const UT_StringArray&
                            commandArgs() const
                                { return myCommandArgs; }

    /// Returns the current name of the service client
    inline const UT_StringHolder&
                            name() const
                                { return myName; }

    /// Returns the log path for the client
    inline const UT_StringHolder&
                            logPath() const
                                { return myLogPath; }

    /// Returns the MQ connection address
    inline const UT_StringHolder&
                            address() const
                                { return myAddress; }


    /// Returns the client number
    inline exint            clientNumber() const
                                { return myClientNumber; }

    /// Returns the MQ connection port
    inline exint            port() const
                                { return myPort; }

    /// Returns the process or job ID
    inline exint            id() const
                                { return myId; }

    /// Sets the current job ID
    inline void             setId(exint id)
                                { myId = id; }

    /// Returns the total number of jobs the client has cooked
    inline exint            totalCooks() const
                                { return myTotalCooks; }

    /// Returns the current memory usage
    inline exint            memoryUsage() const
                                { return myMemoryUsage; }


    /// Gets the current client work item lock, or -1 if one isn't set
    inline PDG_WorkItemID   lock() const
                                { return myLock; }

    /// Returns whether or not the client is connected to the MQ
    inline bool             isConnected() const
                                { return myIsConnected; }

    /// Returns whether or not the client is active
    inline bool             isActive() const
                                { return myIsActive; }

private:
    friend class PDG_Service;

    /// Spawns the client as a child process, and returns true on
    /// success
    bool                    spawnProcess();

    /// Kills the active client process, if one exists
    bool                    killProcess(
                                UT_WorkBuffer& errors,
                                PDG_Service* service,
                                PDG_Scheduler* scheduler);

    /// Waits for the active client process, if one exists, and returns
    /// its exit code
    int                     waitProcess();

    /// Checks if the spawned process is still valid and active
    bool                    hasValidProcess();

    /// Marks the client as in use, which also increments its total cook
    /// count and sets the lock if a non-empty ID is passed in
    void                    startCook(PDG_WorkItemID lock_id);

    /// Marks the client as no longer in use, and reports its last known
    /// memory usage
    void                    stopCook(exint memory_usage);

    /// Sets whether or no the client is connected
    void                    setConnected(bool connected);

    /// Unlocks the client
    void                    setUnlocked();

    /// Resets the total cooks and memory usage of the client
    void                    resetStats();

    /// Starts an operation that can time out, with the given timeout value
    /// in seconds
    void                    startTimeout(fpreal timeout);

    /// Updates and checks the current timeout operation, returns true if
    /// the timeout has been reached
    bool                    updateTimeout(fpreal delta);

private:
    /// The array of command line args for the client
    UT_StringArray          myCommandArgs;

    /// The name of the service client
    UT_StringHolder         myName;

    /// The log path for client output
    UT_StringHolder         myLogPath;

    /// The connection address
    UT_StringHolder         myAddress;


    /// The current timeout, for operations that should be limited
    /// to a maximum wait time. When this hits 0 the operation should be
    /// canceled.
    fpreal                  myCurrentTimeout;


    /// The client number, within the list of all clients for the service
    exint                   myClientNumber;

    /// The connection port
    exint                   myPort;

    /// The process or job id for the client
    exint                   myId;

    /// The total number of tasks the service has cooked
    exint                   myTotalCooks;

    /// The amount of memory in use by the process, as recorded by the
    /// last task that cooked using the client
    int64                   myMemoryUsage;


    /// The ID of the work item that has locked the service client, if
    /// any
    PDG_WorkItemID          myLock;

    /// Set to true once the client has connected
    bool                    myIsConnected;

    /// Set to true if the client is active for a job
    bool                    myIsActive;
};

#endif