MClientLib.h

Go to the documentation of this file.

/*****************************************************************************
**                                       
**  Header file for Muster API Client lib
**
**  Name    : MClientLib.h
**  Author  : Leonardo Bernardini
**  Version : 1.0, Sat Mar 2nd 2013
**
**  Copyright 2000-2014, Virtual Vertex
**  All Rights Reserved.
**
**  This file contains UNPUBLISHED PROPRIETARY SOURCE CODE.
**  The contents of this file may not be disclosed to third parties, copied
**  or duplicated in any form, in whole or in part, without the prior written
**  permission of the author.
**
*****************************************************************************/
#ifndef MCLIENTLIB_H
#define MCLIENTLIB_H

#include <vector>
#include <string>

#include "MClientLib/MError.h"
#include "MClientLib/MSession.h"
#include "MClientLib/MAuth.h"
#include "MClientLib/MConfiguration.h"
#include "MClientLib/MServerStatus.h"
#include "MClientLib/MLog.h"
#include "MClientLib/MChunk.h"
#include "MClientLib/MNode.h"
#include "MClientLib/MJob.h"
#include "MClientLib/MPools.h"
#include "MClientLib/MMaillist.h"
#include "MClientLib/MRepository.h"
#include "MClientLib/MUser.h"
#include "MClientLib/MGroup.h"
#include "MClientLib/MDispatcherStatistics.h"
#include "MClientLib/MStatisticsSample.h"
#include "MClientLib/MHistoryChunk.h"
#include "MClientLib/MNodeConfiguration.h"
#include "MClientLib/MStringRef.h"
#include "MClientLib/MSamplesBoundaries.h"

#ifdef WIN32
// Windows definitions
#ifdef MCLIENTLIB_EXPORTS
#define MCLIENTLIB_API __declspec(dllexport)
#else
#define MCLIENTLIB_API __declspec(dllimport)
#endif
#else

#ifndef MCLIENTLIB_EXPORTS
#ifdef LINUX
#define MCLIENTLIB_API
#else
#define MCLIENTLIB_API
#endif
#else
#define MCLIENTLIB_API
#endif

#endif

namespace MClientLib {
    
    enum kPlatforms {
        kPlatformWindows = 0x01, 
        kPlatformLinux = 0x02, 
        kPlatformOSX = 0x04 
    } ;

    enum kNetworkCommands {
        kD2HStartProcess = 1,       
        kD2HKillProcess,            
        kD2HKillProcessAndRestart, 
        kD2HKillProcessAndPause, 
        kD2HPauseNode, 
        kD2HResumeNode, 
        kD2HForceUpdate, 
        kD2HSetProcessPriority, 
        kD2HAckAndGoIdle, 
        kD2HPulseHeartbeat, 
        kD2HSoftRestartNode, 
        kD2HEnableNodeLog, 
        kD2HDisableNodeLog, 
        kD2HSysEvent, 
        kH2DReportProcResult_WarningOnLog = 200, 
        kH2DReportProcResult_Success, 
        kH2DReportProcResult_ErrorOnLog,  
        kH2DReportProcResult_WarningOnExitcode,  
        kH2DReportProcResult_ErrorOnExitcode,  
        kH2DReportProcResult_ProcessSpawnFailure,  
        kH2DReportProcResult_FailureOnPrechunkAction,  
        kH2DReportProcResult_FailureOnPostchunkAction,  
        kH2DStatus,  
        kH2DIdle,  
        kH2DPaused, 
        kH2DProcessStatus, 
        kH2DPulseHeartbeat, 
        kH2DClientID, 
        kH2DLockedByLoggedUser, 
        kH2DLockedByProcess, 
        kH2DLockedByTimerule, 
        kH2DLogChunk, 
        kD2NNotifyJob = 600, 
        kD2NNotifyJobWithWarnings, 
        kD2NNotifyJobWithWarningsInProgress, 
        kD2NNotifyAlert, 
        kD2NNotifyInfo, 
        kD2NNotifyService, 
        kD2NNotifyError, 
        kD2NNotifyLogin, 
        kC2DRequestStatisticsBoundaries = 800, 
        kC2DStartStatisticsRequest, 
        kC2DRequestNextStatisticsEntry, 
        kC2DStartHistoryRequest, 
        kC2DRequestNextHistoryEntry, 
        kC2DStartChunksHistoryRequest, 
        kC2DRequestNextChunksHistoryEntry, 
        kC2DHistoryClearBounds, 
        kC2DStatisticsClearBounds, 
        kC2DDragJobToNewParent, 
        kC2DLogin, 
        kC2DSetNetMask, 
        kC2DSendRegistration, 
        kC2DQueryEngineStatus, 
        kC2DSwapEngineStatus, 
        kC2DStartLogsRequest, 
        kC2DRequestNextLogsEntry, 
        kC2DClearInternalLog, 
        kC2DStartPathsRequest, 
        kC2DRequestNextPathsEntry, 
        kC2DStartUsersRequest, 
        kC2DRequestNextUsersEntry, 
        kC2DStartPoolsRequest, 
        kC2DRequestNextPoolsEntry, 
        kC2DStartJobsRequest, 
        kC2DRequestNextJobsEntry, 
        kC2DStartNodesRequest, 
        kC2DRequestNextNodesEntry, 
        kC2DStartChunksRequest, 
        kC2DRequestNextChunksEntry, 
        kC2DModifyJob, 
        kC2DRenameJob, 
        kC2DChangeJobPriority, 
        kC2DChangeJobDepartment, 
        kC2DChangeJobProject, 
        kC2DChangeJobTemplate, 
        kC2DSubmitJob, 
        kC2DDeleteJob, 
        kC2DChangeJobPool, 
        kC2DChangeJobExcludedPool, 
        kC2DChangeJobOwner, 
        kC2DPauseJob, 
        kC2DResumeJob, 
        kC2DReinitJob, 
        kC2DChangeJobDependancies, 
        kC2DChangeJobDependanciesMode, 
        kC2DChangeJobStartOn, 
        kC2DChangeJobResumeOn, 
        kC2DChangeJobPauseOn, 
        kC2DUnlockJob, 
        kC2DLockJob, 
        kC2DArchiveJob, 
        kC2DUnarchiveJob, 
        kC2DImportQueue, 
        kC2DExportQueue, 
        kC2DPauseNode, 
        kC2DResumeNode, 
        kC2DKillNode, 
        kC2DKillAndPauseNode, 
        kC2DKillNodeAndRedoJob, 
        kC2DChangeNodeProcessPriority, 
        kC2DPurgeTemplatesExclusion, 
        kC2DPurgeJobsExclusion, 
        kC2DSoftRestartNode, 
        kC2DSoftRestartDispatcher, 
        kC2DKillAndPauseNodesWorkingOnJob, 
        kC2DKillAndRedoNodesWorkingOnJob, 
        kC2DKillAndGoOnNodesWorkingOnJob, 
        kC2DPrepareBuffersForBigOP, 
        kC2DRestoreBuffersAfterBigOP, 
        kC2DChangePassword, 
        kC2DForceStatisticsUpdate, 
        kC2DResetStatisticsCounters, 
        kC2DChangeNodeMemo, 
        kC2DRemoveNodeRegistration, 
        kC2DStartNetworkScan, 
        kC2DRegisterNode, 
        kC2DReparentJob, 
        kC2DSendSystemEventToNode, 
        kC2DSetChunkOnHold, 
        kC2DSetChunkAsCompleted, 
        kC2DRequestPreferences, 
        kC2DSetPreferences, 
        kC2DEnableNodeLog, 
        kC2DDisableNodeLog, 
        kC2DRequestActivityLogsList, 
        kC2DRequestActivityLog, 
        kC2DRemoveActivityLog, 
        kC2DRequestActionsLogsList, 
        kC2DRequestActionsLog, 
        kC2DRemoveActionsLog, 
        kC2DStartMailsRequest, 
        kC2DUpdateNodeWakeupStatus, 
        kC2DAddFolder, 
        kC2DChangeJobMemo, 
        kC2DChangeJobMaximumInstances, 
        kC2DForceNodeRefresh, 
        kC2DRequestMailsEntry, 
        kC2DSetMinimumLogicalUnits, 
        kC2DSetMinimumCores, 
        kC2DSetMinimumPhysicalUnits, 
        kC2DSetMinimumCoresSpeed, 
        kC2DSetMinimumRamAmount, 
        kC2DSetMinimumDiskSpaceAmount, 
        kC2DSetProcessValidExitCodes, 
        kC2DSetProcessWarningExitCodes, 
        kC2DSetProcessErrorExitCodes, 
        kC2DSetProcessValidLogTexts, 
        kC2DSetProcessWarninigLogTexts, 
        kC2DSetProcessErrorLogTexts, 
        kC2DStartUsersGroupsRequest, 
        kC2DRequestNextUsersGroupsEntry, 
        kC2DUpdateLDAPUsers, 
        kC2DRequestLDAPSettings, 
        kC2DConfigureLDAP, 
        kD2CLDAPUsersUpdateError, 
        kC2DStartJobsUpdateRequest, 
        kC2DRequestNextJobsUpdateEntry, 
        kC2DAddUser, 
        kC2DGetUser, 
        kC2DConfigureUser, 
        kC2DRemoveUser, 
        kC2DAddGroup, 
        kC2DGetGroup, 
        kC2DConfigureGroup, 
        kC2DRemoveGroup, 
        kC2DGetJob, 
        kC2DGetNode, 
        kC2DGetChunk, 
        kC2DSetEnvironment, 
        kC2DChangeExitCodesCheck, 
        kC2DChangeLogsCheck, 
        kC2DChangeMissingFramesCheck, 
        kC2DChangeFramesPrefixPath, 
        kD2CStatisticsBoundaries = 1000, 
        kD2CStatisticsEntry, 
        kD2CStatisticsStreamingStarting, 
        kD2CStatisticsStreamingCompleted, 
        kD2CHistoryEntry, 
        kD2CHistoryStreamingStarting, 
        kD2CHistoryStreamingCompleted, 
        kD2CChunksHistoryEntry, 
        kD2CChunksHistoryStreamingStarting, 
        kD2CChunksHistoryStreamingCompleted, 
        kD2CStatisticsBoundsCleared, 
        kD2CHistoryBoundsCleared, 
        kD2CPasswordChangeSuccess, 
        kD2CConfigChangeSuccess, 
        kD2CImportQueueResponse, 
        kD2CExportQueueResponse, 
        kD2CExportQueueError, 
        kD2CImportQueueError, 
        kD2CExportImportBuffersReady, 
        kD2CStatisticsLiveSnapshot, 
        kD2CMailsStreamingStarting, 
        kD2CMailsEntry, 
        kD2CMailsStreamingCompleted, 
        kD2CJobsStreamingEntry, 
        kD2CJobsStreamingCompleted, 
        kD2CJobsStreamingStarting, 
        kD2CJobLiveUpdate, 
        kD2CJobLiveAdd, 
        kD2CJobLiveRemove, 
        kD2CForceJobsUpdate, 
        kD2CNodesStreamingEntry, 
        kD2CNodesStreamingCompleted, 
        kD2CNodesStreamingStarting, 
        kD2CNodeLiveUpdate  , 
        kD2CNodeLiveAdd, 
        kD2CNodeLiveRemove, 
        kD2CChunksStreamingEntry, 
        kD2CChunksStreamingCompleted, 
        kD2CChunksStreamingStarting, 
        kD2CChunkLiveUpdate, 
        kD2CChunksInvalidated, 
        kD2CPreferencesContent, 
        kD2CPoolsStreamingStarting, 
        kD2CPoolsStreamingEntry, 
        kD2CPoolsStreamingCompleted, 
        kD2CPoolsContentChanged, 
        kD2CUsersStreamingStarting, 
        kD2CUsersStreamingEntry, 
        kD2CUsersStreamingCompleted, 
        kD2CPathsStreamingStarting, 
        kD2CPathsStreamingEntry, 
        kD2CPathsStreamingCompleted, 
        kD2CPathsContentChanged, 
        kD2CLogsStreamingStarting, 
        kD2CLogsStreamingEntry, 
        kD2CLogsStreamingCompleted, 
        kD2CInternalLogCleared, 
        kD2CLiveLogAdd, 
        kD2CLoginResponse, 
        kD2CUnauthorizedOperationAttempt, 
        kD2CInvalidOperationAttempt, 
        kD2COperationSuccessfully, 
        kD2CRegistrationSuccessfully, 
        kD2CRegistrationInvalid, 
        kD2CRegistrationTemporary, 
        kD2CRegistrationExpired, 
        kD2CEngineStatus, 
        kD2CLiveLogChunk, 
        kD2CInvalidLogEntryRequested, 
        kD2CUsersGroupsStreamingStarting, 
        kD2CUsersGroupsStreamingEntry, 
        kD2CUsersGroupsStreamingCompleted, 
        kD2CUsersGroupsStreamingRequest, 
        kD2CLDAPUsersUpdateComplete, 
        kD2CLDAPUsersUpdateInProgress, 
        kD2CLDAPSettings, 
        kD2CLDAPConfigureComplete, 
        kD2CJobsUpdateStreamingEntry, 
        kD2CJobsUpdateStreamingCompleted, 
        kD2CJobsUpdateStreamingStarting, 
        kD2CGetJobResponse, 
        kD2CGetNodeResponse, 
        kD2CGetChunkResponse, 
        kC2HConfigure = 1200, 
        kC2HRequestStatus, 
        kC2HPauseNode, 
        kC2HResumeNode, 
        kC2HKillAndPauseNode, 
        kC2HKillAndGoOnNode, 
        kC2HKillAndRedoNode, 
        kC2HChangeNodePriority, 
        kC2HRequestInstances, 
        kC2HRequestLogs, 
        kC2HRequestLogEntry, 
        kC2HRemoveLog   , 
        kC2HRequestActivityLogs, 
        kC2HRequestActivityLogEntry , 
        kC2HRemoveActivityLog, 
        kC2HAuthenticate,    
        kH2CStatusContent = 1400, 
        kH2CConfigurationContent, 
        kH2CRequestInstancesResponse, 
        kH2CInvalidLogRequest, 
        kH2CUnauthorizedOperationAttempt, 
        kE2DRequestTemplates = 1600, 
        kE2DRequestNextTemplatesStreamingEntry, 
        kE2DRequestTemplatesHashesMap, 
        kE2DRequestTemplate, 
        kD2ETemplatesStreamingStarting = 1800, 
        kD2ETemplatesStreamingCompleted, 
        kD2ETemplatesStreamingEntry, 
        kD2ETemplateContent, 
        kD2ETemplatesHashesMap, 
        kD2ETemplatesReconfigurationCompleted, 
        kD2ETemplatesContentChanged, 
        kCustomMessage = 10000 
    };

    enum kLoginResponse {
        kLoginAdmin = 0x00, 
        kLoginUser, 
        kLoginGuest, 
        kLoginDenied, 
        kLoginDeniedLDAPDown, 
    };

    enum kNetworkMasks {
        kNetworkMaskJobs = 0x01, 
        kNetworkMaskHosts = 0x02, 
        kNetworkMaskLogs = 0x04, 
        kNetworkMaskArchiviedJobs = 0x08 
    };

    MCLIENTLIB_API MUSTERERR InitializeLibrary(const char* module); 
    
    MCLIENTLIB_API void ShutdownLibrary(); 

    MCLIENTLIB_API std::string GetLibraryPath();

    MCLIENTLIB_API int GetPlatform();

    MCLIENTLIB_API void LoadTemplates(const char* templatesPath); 

    MCLIENTLIB_API MUSTERCLIENT* InitializeClientSession(void); 
    
    MCLIENTLIB_API void ShutdownClientSession(MUSTERCLIENT* m);

    MCLIENTLIB_API void SetClientSessionAsync(MUSTERCLIENT* m, bool state);

    MCLIENTLIB_API MUSTERERR Connect(MUSTERCLIENT* m,const char* clientAddress, int clientPort,long maxSocketReadBytes = 65000000,
        long maxSocketWriteBytes = 65000000);

    MCLIENTLIB_API MUSTERERR Disconnect(MUSTERCLIENT* m);
    
    MCLIENTLIB_API MUSTERERR MNetTask(MUSTERCLIENT* m);

    MCLIENTLIB_API MUSTERERR MNetSendMessage(MUSTERCLIENT* m,int message, int actionId,const char* parameters = 0, bool waitForCompletion = true);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForMessage(MUSTERCLIENT* m,int message, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForMessages(MUSTERCLIENT* m,int messages[], int messagesCount, int actionId = 0);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForActionCompletation(MUSTERCLIENT* m, int actionId);
    
    MCLIENTLIB_API MUSTERERR MNetGetNextMessage(MUSTERCLIENT* m);

    MCLIENTLIB_API int MNetGetCurrentMessage(MUSTERCLIENT* m);
    
    MCLIENTLIB_API int MNetGetCurrentMessageActionId(MUSTERCLIENT* m);

    MCLIENTLIB_API std::vector<std::string> MNetGetCurrentMessageParameters(MUSTERCLIENT* m);

    MCLIENTLIB_API char* MNetGetCurrentMessageData(MUSTERCLIENT* m);

    MCLIENTLIB_API MUSTERERR Authenticate(MUSTERCLIENT*m, const char* password);

    MCLIENTLIB_API MUSTERERR GetNodeConfiguration(MUSTERCLIENT* m, MNodeConfiguration& configurationObject);

    MCLIENTLIB_API MUSTERERR SendNodeConfiguration(MUSTERCLIENT* m, MNodeConfiguration& configurationObject);

    MCLIENTLIB_API MUSTERERR GetActivityLogs(MUSTERCLIENT*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActivityLogContent(MUSTERCLIENT*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActivityLog(MUSTERCLIENT*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetProcessesLogs(MUSTERCLIENT*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetProcessesLogContent(MUSTERCLIENT* m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveProcessesLog(MUSTERCLIENT* m, const char* filename);

    MCLIENTLIB_API MUSTER* InitializeSession(void); 

    MCLIENTLIB_API void ShutdownSession(MUSTER* m);
    
    MCLIENTLIB_API void SetSessionAsync(MUSTER* m, bool state);

    MCLIENTLIB_API MUSTERERR Connect(MUSTER* m,const char* dispatcherAddress, int dispatcherPort,long maxSocketReadBytes = 65000000,
        long maxSocketWriteBytes = 65000000);

    MCLIENTLIB_API MUSTERERR Disconnect(MUSTER* m);

    MCLIENTLIB_API MUSTERERR MNetTask(MUSTER* m);

    MCLIENTLIB_API MUSTERERR MNetSendMessage(MUSTER* m,int message, int actionId,const char* parameters = 0, bool waitForCompletion = true);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForMessage(MUSTER* m,int message, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForMessages(MUSTER* m,int messages[], int messagesCount, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForActionCompletation(MUSTER* m, int actionId);

    MCLIENTLIB_API MUSTERERR MNetGetNextMessage(MUSTER* m);

    MCLIENTLIB_API int MNetGetCurrentMessage(MUSTER* m);

    MCLIENTLIB_API int MNetGetCurrentMessageActionId(MUSTER* m);

    MCLIENTLIB_API std::vector<std::string> MNetGetCurrentMessageParameters(MUSTER* m);

    MCLIENTLIB_API char* MNetGetCurrentMessageData(MUSTER* m);

    MCLIENTLIB_API MServerStatus GetServerStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERAUTH GetAuthenticationStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR GetJobs(MUSTER*m, int filterMask, std::vector<MJob>& jobs, bool queryArchivied);

    MCLIENTLIB_API MUSTERERR GetNodes(MUSTER*m, int filterMask, std::vector<MNode>& nodes);

    MCLIENTLIB_API MUSTERERR GetLogs(MUSTER*m, int filterMask, std::vector<MLog>& logs);

    MCLIENTLIB_API MUSTERERR GetChunks(MUSTER*m, long jobId, int filterMask, std::vector<MChunk>& chunks);
    
    MCLIENTLIB_API MUSTERERR GetJob(MUSTER*m, MJob& job, long jobId);

    MCLIENTLIB_API MUSTERERR GetNode(MUSTER*m,MNode& node, long nodeId);

    MCLIENTLIB_API MUSTERERR GetChunk(MUSTER*m, MChunk& chunk, long jobId, long chunkId);

    MCLIENTLIB_API MUSTERERR Authenticate(MUSTER* m, const char* username, const char* password, bool skipDirectoryServer = false);

    MCLIENTLIB_API MUSTERERR AcquireServerStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR SynchronizeTemplates(MUSTER* m); 

    MCLIENTLIB_API MUSTERERR GetDispatcherConfiguration(MUSTER* m, MDispatcherConfiguration& configurationObject);
    
    MCLIENTLIB_API MUSTERERR SendDispatcherConfiguration(MUSTER* m, MDispatcherConfiguration& configurationObject);
    
    MCLIENTLIB_API MUSTERERR GetDispatcherLDAPConfiguration(MUSTER* m, MDispatcherConfigurationLDAP& configurationObject);
    
    MCLIENTLIB_API MUSTERERR SendDispatcherLDAPConfiguration(MUSTER* m, MDispatcherConfigurationLDAP& configurationObject);

    MCLIENTLIB_API MUSTERERR GetPools(MUSTER*m, MPools& pools);

    MCLIENTLIB_API MUSTERERR SetPools(MUSTER*m, MPools& pools);

    MCLIENTLIB_API MUSTERERR GetAccounts(MUSTER* m , std::vector<MUser>& users, std::vector<MGroup>& groups);
    
    MCLIENTLIB_API MUSTERERR SendAccounts(MUSTER* m, std::vector<MUser>& users, std::vector<MGroup>& groups);

    MCLIENTLIB_API MUSTERERR AddUser(MUSTER* m, MUser& user);

    MCLIENTLIB_API MUSTERERR GetUser(MUSTER* m , const char* userName,MUser& user );
    
    MCLIENTLIB_API MUSTERERR ConfigureUser(MUSTER* m, MUser& user);

    MCLIENTLIB_API MUSTERERR RemoveUser(MUSTER* m, const char* userName);
    
    MCLIENTLIB_API MUSTERERR AddGroup(MUSTER* m, MGroup& group);

    MCLIENTLIB_API MUSTERERR GetGroup(MUSTER* m , const char* groupName,MGroup& group );

    MCLIENTLIB_API MUSTERERR ConfigureGroup(MUSTER* m, MGroup& group);

    MCLIENTLIB_API MUSTERERR RemoveGroup(MUSTER* m, const char* groupName);

    MCLIENTLIB_API MUSTERERR GetMails(MUSTER* m, std::vector<MMailList>& mails);

    MCLIENTLIB_API MUSTERERR SetMails(MUSTER* m, std::vector<MMailList>& mails);

    MCLIENTLIB_API MUSTERERR GetRepositories(MUSTER*m, std::vector<MRepository>& repositories);

    MCLIENTLIB_API MUSTERERR SetRepositories(MUSTER*m, std::vector<MRepository>& repositories);

    MCLIENTLIB_API MUSTERERR GetActivityLogs(MUSTER*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActivityLogContent(MUSTER*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActivityLog(MUSTER*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetActionLogs(MUSTER*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActionLogContent(MUSTER*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActionLog(MUSTER*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetHistoryBounds(MUSTER*m, MSamplesBoundaries& boundaries);

    MCLIENTLIB_API MUSTERERR GetStatisticsHistory(MUSTER*m, long startingTime, long endingTime, std::vector<MStatisticsSample>& samples);

    MCLIENTLIB_API MUSTERERR ClearStatisticsHistory(MUSTER*m, long startingTime, long endingTime);

    MCLIENTLIB_API MUSTERERR GetJobsHistory(MUSTER*m, long startingTime, long endingTime, const char* filterField, const char* filter, std::vector<MHistoryChunk>& samples);

    MCLIENTLIB_API MUSTERERR ClearJobsHistory(MUSTER*m, long startingTime, long endingTime);

    MCLIENTLIB_API MUSTERERR GetJobHistory(MUSTER*m, long jobId, std::vector<MHistoryChunk>& samples);

    MCLIENTLIB_API MUSTERERR GetStatistics(MUSTER*m, MDispatcherStatistics& statistics);

    MCLIENTLIB_API MUSTERERR ActionForceLDAPUpdate(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionImportQueue(MUSTER* m, MStringRef& in);

    MCLIENTLIB_API MUSTERERR ActionExportQueue(MUSTER* m, MStringRef& out);

    MCLIENTLIB_API MUSTERERR ActionSoftRestart(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionResetCounters(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionChangeStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionChangePassword(MUSTER* m,const char* oldPassword, const char* newPassword);

    MCLIENTLIB_API MUSTERERR ActionSendJob(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR ActionEditJob(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR ActionCreateFolder(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR NodeActionSoftRestart(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionPause(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionResume(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndGo(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndRedo(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndPause(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionChangeNotes(MUSTER* m, long nodeId, const char* notes);

    MCLIENTLIB_API MUSTERERR NodeActionSoftRestart(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionResume(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndGo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndRedo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionChangeNotes(MUSTER* m, std::vector<long> id, const char* notes);

    MCLIENTLIB_API MUSTERERR JobActionKillAndPause(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionKillAndRedo(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionKillAndGoOn(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionUnlock(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionLock(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionArchive(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionUnarchive(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionPause(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionResume(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionReinit(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionRename(MUSTER* m, long jobId,const char* name);

    MCLIENTLIB_API MUSTERERR JobActionSetProject(MUSTER* m, long jobId,const char* groupName);

    MCLIENTLIB_API MUSTERERR JobActionSetDepartment(MUSTER* m, long jobId,const char* departmentName);

    MCLIENTLIB_API MUSTERERR JobActionSetOwner(MUSTER* m, long jobId,const char* ownerName);

    MCLIENTLIB_API MUSTERERR JobActionSetPriority(MUSTER* m, long jobId,int priority);

    MCLIENTLIB_API MUSTERERR JobActionSetPools(MUSTER* m, long jobId,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetExcludedPools(MUSTER* m, long jobId,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetMaximumNodes(MUSTER* m, long jobId,int maximumNodes);

    MCLIENTLIB_API MUSTERERR JobActionSetParent(MUSTER* m, long jobId,long parentId);

    MCLIENTLIB_API MUSTERERR JobActionSetTemplate(MUSTER* m, long jobId,int templateId);

    MCLIENTLIB_API MUSTERERR JobActionSetDepends(MUSTER* m, long jobId,const char* depends);

    MCLIENTLIB_API MUSTERERR JobActionSetDependMode(MUSTER* m, long jobId,int dependMode);

    MCLIENTLIB_API MUSTERERR JobActionSetStartsOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetResumeOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetPauseOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetNotes(MUSTER* m, long jobId,const char* notes);

    MCLIENTLIB_API MUSTERERR JobActionDelete(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumLogicalUnits(MUSTER* m, long jobId,bool enable,int minimumLogicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCores(MUSTER* m, long jobId,bool enable,int minimumCores);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalUnits(MUSTER* m, long jobId,bool enable,int minimumPhysicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCoresSpeed(MUSTER* m, long jobId,bool enable,double minimumCoreSpeed);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumRamAmount(MUSTER* m, long jobId,bool enable,double minimumRamAmount);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumDiskSpaceAmount(MUSTER* m, long jobId,bool enable,double minimumDiskSpace);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidExitCodes(MUSTER* m, long jobId,bool enable,const char* validExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningExitCodes(MUSTER* m, long jobId,bool enable,const char* warningExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorExitCodes(MUSTER* m, long jobId,bool enable,const char* errorExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidLogTexts(MUSTER* m, long jobId,bool enable,const char* validLogTexts);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningLogTexts(MUSTER* m, long jobId,bool enable,const char* warningLogTexts);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorLogTexts(MUSTER* m, long jobId,bool enable,const char* errorLogTexts);

    MCLIENTLIB_API MUSTERERR JobActionKillAndPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionKillAndRedo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionKillAndGoOn(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionUnlock(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionLock(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionArchive(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionUnarchive(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionResume(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionReinit(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionSetProject(MUSTER* m, std::vector<long> id,const char* groupName);
    
    MCLIENTLIB_API MUSTERERR JobActionSetDepartment(MUSTER* m, std::vector<long> id,const char* departmentName);

    MCLIENTLIB_API MUSTERERR JobActionSetOwner(MUSTER* m, std::vector<long> id,const char* ownerName);

    MCLIENTLIB_API MUSTERERR JobActionSetPriority(MUSTER* m, std::vector<long> id,int priority);
    
    MCLIENTLIB_API MUSTERERR JobActionSetPools(MUSTER* m,std::vector<long> id,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetExcludedPools(MUSTER* m, std::vector<long> id,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetMaximumNodes(MUSTER* m,std::vector<long> id,int maximumNodes);

    MCLIENTLIB_API MUSTERERR JobActionSetParent(MUSTER* m, std::vector<long> id,long parentId);

    MCLIENTLIB_API MUSTERERR JobActionSetTemplate(MUSTER* m, std::vector<long> id,int templateId);

    MCLIENTLIB_API MUSTERERR JobActionSetDepends(MUSTER* m, std::vector<long> id,const char* depends);

    MCLIENTLIB_API MUSTERERR JobActionSetDependMode(MUSTER* m, std::vector<long> id,int dependMode);

    MCLIENTLIB_API MUSTERERR JobActionSetStartsOn(MUSTER* m, std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetResumeOn(MUSTER* m,std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetPauseOn(MUSTER* m,std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetNotes(MUSTER* m, std::vector<long> id,const char* notes);

    MCLIENTLIB_API MUSTERERR JobActionDelete(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumLogicalUnits(MUSTER* m, std::vector<long> id,bool enable,int minimumLogicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCores(MUSTER* m, std::vector<long> id,bool enable,int minimumCores);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalUnits(MUSTER* m, std::vector<long> id,bool enable,int minimumPhysicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCoresSpeed(MUSTER* m, std::vector<long> id,bool enable,double minimumCoreSpeed);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumRamAmount(MUSTER* m, std::vector<long> id,bool enable,double minimumRamAmount);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumDiskSpaceAmount(MUSTER* m, std::vector<long> id,bool enable,double minimumDiskSpace);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* validExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* warningExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* errorExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidLogTexts(MUSTER* m, std::vector<long> id,bool enable,const char* validLogTexts);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningLogTexts(MUSTER* m, std::vector<long> id,bool enable,const char* warningLogTexts);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorLogTexts(MUSTER* m, std::vector<long> id,bool enable,const char* errorLogTexts);

    MCLIENTLIB_API MUSTERERR ChunkActionSetOnHold(MUSTER* m,long jobId,long chunkId);

    MCLIENTLIB_API MUSTERERR ChunkActionSetCompleted(MUSTER* m,long jobId,long chunkId);
        
    MCLIENTLIB_API MUSTERERR ChunkActionSetOnHold(MUSTER* m,long jobId,std::vector<long> id);

    MCLIENTLIB_API MUSTERERR ChunkActionSetCompleted(MUSTER* m,long jobId,std::vector<long> id);

}

#endif