MConfiguration.h

Go to the documentation of this file.

/*****************************************************************************
 **
 **  Header file for Muster API configuration object
 **
 **  Name    : MConfiguration.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 MCONFIGURATION_H
#define MCONFIGURATION_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

#if defined(_WIN32)
#pragma warning(disable: 4251)
#endif // _WIN32

#include <MClientLib/MDriveMap.h>

namespace MClientLib {

    class MCLIENTLIB_API MDispatcherConfigurationGeneral {
    private:
        bool engineStartup;
        bool enableWebServer;
    public:
        MDispatcherConfigurationGeneral();
        bool getEngineStartup(); 
        bool getEnableWebServer(); 
        void setEngineStartup(bool); 
        void setEnableWebServer(bool); 
    };

    class MCLIENTLIB_API MDispatcherConfigurationDatabase {
    private:
        std::string username;
        std::string password;
        std::string address;
        std::string engine;
        std::string dbName;
        std::string historyDbName;

    public:
        MDispatcherConfigurationDatabase();
        void setUsername(const std::string&); 
        void setPassword(const std::string&); 
        void setAddress(const std::string&); 
        void setEngine(const std::string&); 
        void setDbName(const std::string&); 
        void setHistoryDbName(const std::string&); 
        std::string getUsername(); 
        std::string getPassword(); 
        std::string getAddress(); 
        std::string getEngine(); 
        std::string getDbName(); 
        std::string getHistoryDbName(); 
    };

    class MCLIENTLIB_API MDispatcherConfigurationBehaviours {
    private:
        bool removeOrphanedInstances;
        int instancesDistinguish;
        bool requeueOnDisconnection;
        bool requeueOnTimeout;
        int requeueOnTimeoutTimer;
        bool requeueKillActiveRenders;
        int maximumChunksRequeue;
        bool submitPausedJobs;
        int maximumThreads;
        bool enableNTAutomapping;
        bool subchunksCalculateProgress;
        bool parallelRendering;
        bool ignorePrioritiesAtFolderLevel;
        std::vector<MDriveMap*> driveMappings;
        int NTAutomappingDisconnectionPolicy;
        bool buildStatusArray;
        bool substitutionIsCaseSensitive;
        bool makeTemplatesSnapshots;
        bool flagCompletedJobsAsArchived;
        bool flagJobsAsArchived;
        int flagJobAsArchivedAmount;
        int flagJobsAsArchivedCounterType;
        bool prefilterParentPool;
        std::string impersonationUsername;
        std::string impersonationPassword;
    public:
        MDispatcherConfigurationBehaviours();
        ~MDispatcherConfigurationBehaviours();

        bool getRemoveOrphanedInstances(); 
        int getInstancesDistinguish();
        bool getRequeueOnDisconnection();
        bool getRequeueOnTimeout();
        int getRequeueOnTimeoutTimer();
        bool getRequeueKillActiveRenders();
        int getOverrideMaximumChunksRequeueValue();
        bool getSubmitPausedJobs();
        int getMaximumThreads();
        bool getEnableNTAutomapping();
        bool getSubchunksCalculateProgress();
        bool getParallelRendering();
        bool getIgnorePrioritiesAtFolderLevel();
        std::vector<MClientLib::MDriveMap> getDriveMappings();
        MClientLib::MDriveMap* addDriveMapping(MClientLib::MDriveMap);
        int getNTAutomappingDisconnectionPolicy();
        bool getBuildStatusArray();
        bool getSubstitutionIsCaseSensitive();
        bool getMakeTemplatesSnapshots();
        bool getFlagCompletedJobsAsArchived();
        bool getFlagJobsAsArchived();
        int getFlagJobAsArchivedAmount();
        int getFlagJobsAsArchivedCounterType();
        bool getPrefilterParentPool();
        std::string getImpersonationUsername();
        std::string getImpersonationPassword();

        void setRemoveOrphanedInstances(bool);
        void setInstancesDistinguish(int);
        void setRequeueOnDisconnection(bool);
        void setRequeueOnTimeout(bool);
        void setRequeueOnTimeoutTimer(int);
        void setRequeueKillActiveRenders(bool);
        void setOverrideMaximumChunksRequeueValue(int);
        void setSubmitPausedJobs(bool);
        void setMaximumThreads(int);
        void setEnableNTAutomapping(bool);
        void setSubchunksCalculateProgress(bool);
        void setParallelRendering(bool);
        void setIgnorePrioritiesAtFolderLevel(bool);
        void setDriveMappings(std::vector<MClientLib::MDriveMap>);
        void setNTAutomappingDisconnectionPolicy(int);
        void setBuildStatusArray(bool);
        void setSubstitutionIsCaseSensitive(bool);
        void setMakeTemplatesSnapshots(bool);
        void setFlagCompletedJobsAsArchived(bool);
        void setFlagJobsAsArchived(bool);
        void setFlagJobAsArchivedAmount(int);
        void setFlagJobsAsArchivedCounterType(int);
        void setPrefilterParentPool(bool);
        void setImpersonationUsername(const std::string&);
        void setImpersonationPassword(const std::string&);
    };

    class MCLIENTLIB_API MDispatcherConfigurationLogs {
    private:
        bool autoClear;
        int autoClearLimit;
        bool sendMailLog;
        int sendMailLogResolution;
        bool logSystemEvents;
        bool logUsersEvents;
        bool logClientsEvents;
        bool logClientsErrorsEvents;
        bool logCommandLine;
        bool logReturnCodes;

        std::string activityLogsFolder;
        bool clearActivityLogsOlderThan;
        int clearActivityLogsOlderThanDays;
        bool clearActivityLogsExceeds;
        int clearActivityLogsExceedsMB;
        int activityLogsSeverity;

        std::string actionsLogsFolder;
        bool clearActionsLogsOlderThan;
        int clearActionsLogsOlderThanDays;
        bool clearActionsLogsExceeds;
        int clearActionsLogsExceedsMB;

    public:
        MDispatcherConfigurationLogs();
        
        bool getAutoClear();
        int getAutoClearLimit();
        bool getSendMailLog();
        int getSendMailLogResolution();
        bool getLogSystemEvents();
        bool getLogUsersEvents();
        bool getLogClientsEvents();
        bool getLogClientsErrorsEvents();
        bool getLogCommandLine();
        bool getLogReturnCodes();

        std::string getActivityLogsFolder();
        bool getClearActivityLogsOlderThan();
        int getClearActivityLogsOlderThanDays();
        bool getClearActivityLogsExceeds();
        int getClearActivityLogsExceedsMB();
        int getActivityLogsSeverity();

        std::string getActionsLogsFolder();
        bool getClearActionsLogsOlderThan();
        int getClearActionsLogsOlderThanDays();
        bool getClearActionsLogsExceeds();
        int getClearActionsLogsExceedsMB();

        void setAutoClear(bool);
        void setAutoClearLimit(int);
        void setSendMailLog(bool);
        void setSendMailLogResolution(int);
        void setLogSystemEvents(bool);
        void setLogUsersEvents(bool);
        void setLogClientsEvents(bool);
        void setLogClientsErrorsEvents(bool);
        void setLogCommandLine(bool);
        void setLogReturnCodes(bool);

        void setActivityLogsFolder(const std::string&);
        void setClearActivityLogsOlderThan(bool);
        void setClearActivityLogsOlderThanDays(int);
        void setClearActivityLogsExceeds(bool);
        void setClearActivityLogsExceedsMB(int);
        void setActivityLogsSeverity(int);

        void setActionsLogsFolder(const std::string&);
        void setClearActionsLogsOlderThan(bool);
        void setClearActionsLogsOlderThanDays(int);
        void setClearActionsLogsExceeds(bool);
        void setClearActionsLogsExceedsMB(int);
    };

    class MCLIENTLIB_API MDispatcherConfigurationNotificator {
    private:
        bool notifyEngineStatusChanges;
        bool notifySoftRestarts;
        bool notifyConfigsChanges;
        bool notifyExclusions;
        bool notifyJobsStarts;
        bool notifyJobsCompletion;
    public:
        MDispatcherConfigurationNotificator();

        bool getNotifyEngineStatusChanges();
        bool getNotifySoftRestarts();
        bool getNotifyConfigsChanges();
        bool getNotifyExclusions();
        bool getNotifyJobsStarts();
        bool getNotifyJobsCompletion();

        void setNotifyEngineStatusChanges(bool);
        void setNotifySoftRestarts(bool);
        void setNotifyConfigsChanges(bool);
        void setNotifyExclusions(bool);
        void setNotifyJobsStarts(bool);
        void setNotifyJobsCompletion(bool);

    };

    class MCLIENTLIB_API MDispatcherConfigurationMailer {
    private:
        std::string smtpServer;
        std::string smtpAccount;
        bool smtpAuth;
        std::string smtpAuthLogin;
        std::string smtpAuthPassword;
        std::string smtpDestination;
        bool enableMailOnJobCompletion;
        std::string jobCompletionType;
        bool enableMailOnChunkCompletion;
        std::string chunkCompletionType;

        std::string templateJobSuccess;
        std::string templateJobError;
        std::string templateJobRequeue;
        std::string templateChunkSuccess;
        std::string templateChunkError;
        std::string templateLog;
        std::string templateLogEntry;

    public:
        MDispatcherConfigurationMailer();

        std::string getSmtpServer();
        std::string getSmtpAccount();
        bool getSmtpAuth();
        std::string getSmtpAuthLogin();
        std::string getSmtpAuthPassword();
        std::string getSmtpDestination();
        bool getEnableMailOnJobCompletion();
        std::string getJobCompletionType();
        bool getEnableMailOnChunkCompletion();
        std::string getChunkCompletionType();

        std::string getTemplateJobSuccess();
        std::string getTemplateJobError();
        std::string getTemplateJobRequeue();
        std::string getTemplateChunkSuccess();
        std::string getTemplateChunkError();
        std::string getTemplateLog();
        std::string getTemplateLogEntry();

        void setSmtpServer(const std::string&);
        void setSmtpAccount(const std::string&);
        void setSmtpAuth(bool);
        void setSmtpAuthLogin(const std::string&);
        void setSmtpAuthPassword(const std::string&);
        void setSmtpDestination(const std::string&);
        void setEnableMailOnJobCompletion(bool);
        void setJobCompletionType(const std::string&);
        void setEnableMailOnChunkCompletion(bool);
        void setChunkCompletionType(const std::string&);

        void setTemplateJobSuccess(const std::string&);
        void setTemplateJobError(const std::string&);
        void setTemplateJobRequeue(const std::string&);
        void setTemplateChunkSuccess(const std::string&);
        void setTemplateChunkError(const std::string&);
        void setTemplateLog(const std::string&g);
        void setTemplateLogEntry(const std::string&);

    };

    class MCLIENTLIB_API MDispatcherConfigurationNetwork {
    private:
        int clientPort;
        int controlPort;
        int notifyPort;
        bool enableKeepAlive;
        int keepAliveResolution;

        int controlIncomingBuffer;
        int controlOutgoingBuffer;
        int clientIncomingBuffer;
        int clientOutgoingBuffer;
        int notificatorOutgoingBuffer;

        bool broadcastStatistics;
        int broadcastStatisticsResolution;
        int statisticsSampleResolution;

        int wakeupOnLanDelay;
        int wakeupOnLanMaximumAttempts;
        int wakeupOnLanWarmup;

    public:
        MDispatcherConfigurationNetwork();
        
        int getClientPort();
        int getControlPort();
        int getNotifyPort();
        bool getEnableKeepAlive();
        int getKeepAliveResolution();
        int getControlIncomingBuffer();
        int getControlOutgoingBuffer();
        int getClientIncomingBuffer();
        int getClientOutgoingBuffer();
        int getNotificatorOutgoingBuffer();
        bool getBroadcastStatistics();
        int getBroadcastStatisticsResolution();
        int getStatisticsSampleResolution();
        int getWakeupOnLanDelay();
        int getWakeupOnLanMaximumAttempts();
        int getWakeupOnLanWarmup();

        void setClientPort(int);
        void setControlPort(int);
        void setNotifyPort(int);
        void setEnableKeepAlive(bool);
        void setKeepAliveResolution(int);
        void setControlIncomingBuffer(int);
        void setControlOutgoingBuffer(int);
        void setClientIncomingBuffer(int);
        void setClientOutgoingBuffer(int);
        void setNotificatorOutgoingBuffer(int);
        void setBroadcastStatistics(bool);
        void setBroadcastStatisticsResolution(int);
        void setStatisticsSampleResolution(int);
        void setWakeupOnLanDelay(int);
        void setWakeupOnLanMaximumAttempts(int);
        void setWakeupOnLanWarmup(int);
    };

    class MCLIENTLIB_API MDispatcherConfigurationWebserver {
    private:
        int httpPort;
        int httpsPort;
        int maximumBandwidth;
        int socketTimeout;
        int defaultServingThreads;
        int maximumServingThreads;
        int maximumPendingConnections;
        bool enableCompression;
    public:
        MDispatcherConfigurationWebserver();

        int getHttpPort();
        int getHttpsPort();
        int getMaximumBandwidth();
        int getSocketTimeout();
        int getDefaultServingThreads();
        int getMaximumServingThreads();
        int getMaximumPendingConnections();
        bool getEnableCompression();

        void setHttpPort(int);
        void setHttpsPort(int);
        void setMaximumBandwidth(int);
        void setSocketTimeout(int);
        void setDefaultServingThreads(int);
        void setMaximumServingThreads(int);
        void setMaximumPendingConnections(int);
        void setEnableCompression(bool);
    };

    class MCLIENTLIB_API MDispatcherConfigurationFaults {
    private:
        bool enableLogWarning;
        bool logWarningPauseJob;
        bool logWarningPauseNode;
        bool logWarningAddTemplateToExclusion;
        bool logWarningAddJobToExclusion;
        bool logWarningRequeueChunk;

        bool enableLogError;
        bool logErrorPauseJob;
        bool logErrorPauseNode;
        bool logErrorAddTemplateToExclusion;
        bool logErrorAddJobToExclusion;
        bool logErrorRequeueChunk;

        bool enableExitCodeWarning;
        bool exitCodeWarningPauseJob;
        bool exitCodeWarningPauseNode;
        bool exitCodeWarningAddTemplateToExclusion;
        bool exitCodeWarningAddJobToExclusion;
        bool exitCodeWarningRequeueChunk;

        bool enableExitCodeError;
        bool exitCodeErrorPauseJob;
        bool exitCodeErrorPauseNode;
        bool exitCodeErrorAddTemplateToExclusion;
        bool exitCodeErrorAddJobToExclusion;
        bool exitCodeErrorRequeueChunk;

        bool processPauseJob;
        bool processPauseNode;
        bool processAddTemplateToExclusion;
        bool processAddJobToExclusion;
        bool processRequeueChunk;

        bool timeoutPauseJob;
        bool timeoutPauseNode;
        bool timeoutAddTemplateToExclusion;
        bool timeoutAddJobToExclusion;
        bool timeoutKillAnyClient;

    public:
        MDispatcherConfigurationFaults();

        bool getEnableLogWarning();
        bool getLogWarningPauseJob();
        bool getLogWarningPauseNode();
        bool getLogWarningAddTemplateToExclusion();
        bool getLogWarningAddJobToExclusion();
        bool getLogWarningRequeueChunk();

        bool getEnableLogError();
        bool getLogErrorPauseJob();
        bool getLogErrorPauseNode();
        bool getLogErrorAddTemplateToExclusion();
        bool getLogErrorAddJobToExclusion();
        bool getLogErrorRequeueChunk();

        bool getEnableExitCodeWarning();
        bool getExitCodeWarningPauseJob();
        bool getExitCodeWarningPauseNode();
        bool getExitCodeWarningAddTemplateToExclusion();
        bool getExitCodeWarningAddJobToExclusion();
        bool getExitCodeWarningRequeueChunk();

        bool getEnableExitCodeError();
        bool getExitCodeErrorPauseJob();
        bool getExitCodeErrorPauseNode();
        bool getExitCodeErrorAddTemplateToExclusion();
        bool getExitCodeErrorAddJobToExclusion();
        bool getExitCodeErrorRequeueChunk();

        bool getProcessPauseJob();
        bool getProcessPauseNode();
        bool getProcessAddTemplateToExclusion();
        bool getProcessAddJobToExclusion();
        bool getProcessRequeueChunk();

        bool getTimeoutPauseJob();
        bool getTimeoutPauseNode();
        bool getTimeoutAddTemplateToExclusion();
        bool getTimeoutAddJobToExclusion();
        bool getTimeoutKillAnyClient();

        void setEnableLogWarning(bool);
        void setLogWarningPauseJob(bool);
        void setLogWarningPauseNode(bool);
        void setLogWarningAddTemplateToExclusion(bool);
        void setLogWarningAddJobToExclusion(bool);
        void setLogWarningRequeueChunk(bool);

        void setEnableLogError(bool);
        void setLogErrorPauseJob(bool);
        void setLogErrorPauseNode(bool);
        void setLogErrorAddTemplateToExclusion(bool);
        void setLogErrorAddJobToExclusion(bool);
        void setLogErrorRequeueChunk(bool);

        void setEnableExitCodeWarning(bool);
        void setExitCodeWarningPauseJob(bool);
        void setExitCodeWarningPauseNode(bool);
        void setExitCodeWarningAddTemplateToExclusion(bool);
        void setExitCodeWarningAddJobToExclusion(bool);
        void setExitCodeWarningRequeueChunk(bool);

        void setEnableExitCodeError(bool);
        void setExitCodeErrorPauseJob(bool);
        void setExitCodeErrorPauseNode(bool);
        void setExitCodeErrorAddTemplateToExclusion(bool);
        void setExitCodeErrorAddJobToExclusion(bool);
        void setExitCodeErrorRequeueChunk(bool);

        void setProcessPauseJob(bool);
        void setProcessPauseNode(bool);
        void setProcessAddTemplateToExclusion(bool);
        void setProcessAddJobToExclusion(bool);
        void setProcessRequeueChunk(bool);

        void setTimeoutPauseJob(bool);
        void setTimeoutPauseNode(bool);
        void setTimeoutAddTemplateToExclusion(bool);
        void setTimeoutAddJobToExclusion(bool);
        void setTimeoutKillAnyClient(bool);

    };

    class MCLIENTLIB_API MDispatcherConfigurationActions {
    private:
        int actionTimeout;
        bool jobFailurePauseJob;
        bool jobFailureLockJob;
        bool chunkFailureAddJobToExclusion;
        bool chunkFailureAddTemplateToExclusion;
        bool chunkFailureRequeueChunk;
        bool chunkFailureAbortProcessing;

        bool preJobActionEnabled;
        std::string preJobAction;
        bool preJobActionCheckReturnCode;
        int preJobActionReturnCode;
        bool preJobActionOverrideTimeout;
        int preJobActionTimeout;

        bool postJobActionEnabled;
        std::string postJobAction;
        bool postJobActionCheckReturnCode;
        int postJobActionReturnCode;
        bool postJobActionOverrideTimeout;
        int postJobActionTimeout;

        bool preChunkActionEnabled;
        std::string preChunkAction;
        bool preChunkActionCheckReturnCode;
        int preChunkActionReturnCode;
        bool preChunkActionOverrideTimeout;
        int preChunkActionTimeout;

        bool postChunkActionEnabled;
        std::string postChunkAction;
        bool postChunkActionCheckReturnCode;
        int postChunkActionReturnCode;
        bool postChunkActionOverrideTimeout;
        int postChunkActionTimeout;

    public:
        MDispatcherConfigurationActions();

        int getActionTimeout();
        bool getJobFailurePauseJob();
        bool getJobFailureLockJob();
        bool getChunkFailureAddJobToExclusion();
        bool getChunkFailureAddTemplateToExclusion();
        bool getChunkFailureRequeueChunk();
        bool getChunkFailureAbortProcessing();

        bool getPreJobActionEnabled();
        std::string getPreJobAction();
        bool getPreJobActionCheckReturnCode();
        int getPreJobActionReturnCode();
        bool getPreJobActionOverrideTimeout();
        int getPreJobActionTimeout();

        bool getPostJobActionEnabled();
        std::string getPostJobAction();
        bool getPostJobActionCheckReturnCode();
        int getPostJobActionReturnCode();
        bool getPostJobActionOverrideTimeout();
        int getPostJobActionTimeout();

        bool getPreChunkActionEnabled();
        std::string getPreChunkAction();
        bool getPreChunkActionCheckReturnCode();
        int getPreChunkActionReturnCode();
        bool getPreChunkActionOverrideTimeout();
        int getPreChunkActionTimeout();

        bool getPostChunkActionEnabled();
        std::string getPostChunkAction();
        bool getPostChunkActionCheckReturnCode();
        int getPostChunkActionReturnCode();
        bool getPostChunkActionOverrideTimeout();
        int getPostChunkActionTimeout();

        void setActionTimeout(int);
        void setJobFailurePauseJob(bool);
        void setJobFailureLockJob(bool);
        void setChunkFailureAddJobToExclusion(bool);
        void setChunkFailureAddTemplateToExclusion(bool);
        void setChunkFailureRequeueChunk(bool);
        void setChunkFailureAbortProcessing(bool);

        void setPreJobActionEnabled(bool);
        void setPreJobAction(std::string);
        void setPreJobActionCheckReturnCode(bool);
        void setPreJobActionReturnCode(int);
        void setPreJobActionOverrideTimeout(bool);
        void setPreJobActionTimeout(int);

        void setPostJobActionEnabled(bool);
        void setPostJobAction(std::string);
        void setPostJobActionCheckReturnCode(bool);
        void setPostJobActionReturnCode(int);
        void setPostJobActionOverrideTimeout(bool);
        void setPostJobActionTimeout(int);

        void setPreChunkActionEnabled(bool);
        void setPreChunkAction(std::string);
        void setPreChunkActionCheckReturnCode(bool);
        void setPreChunkActionReturnCode(int);
        void setPreChunkActionOverrideTimeout(bool);
        void setPreChunkActionTimeout(int);

        void setPostChunkActionEnabled(bool);
        void setPostChunkAction(std::string);
        void setPostChunkActionCheckReturnCode(bool);
        void setPostChunkActionReturnCode(int);
        void setPostChunkActionOverrideTimeout(bool);
        void setPostChunkActionTimeout(int);
    };

    class MCLIENTLIB_API MDispatcherConfiguration {
    public:
        MDispatcherConfiguration();
        MDispatcherConfigurationGeneral general;
        MDispatcherConfigurationDatabase database;
        MDispatcherConfigurationBehaviours behaviours;
        MDispatcherConfigurationLogs logs;
        MDispatcherConfigurationNotificator notifications;
        MDispatcherConfigurationMailer mailer;
        MDispatcherConfigurationNetwork network;
        MDispatcherConfigurationWebserver webserver;
        MDispatcherConfigurationFaults faults;
        MDispatcherConfigurationActions actions;

        bool Unmarshall(std::vector<std::string>& items);
        std::string Marshall();
    };

    class MCLIENTLIB_API MDispatcherConfigurationLDAP {
    private:

        bool enableBindings;
        int serverType;
        int encryptionType;
        std::string serverAddress;
        int serverPort;
        std::string baseDN;
        std::string groupsBaseDN;
        std::string bindDN;
        std::string bindUsername;
        std::string bindPassword;
        bool updateAutomatically;
        int updateResolution;

        std::string userLDAPAttribute;
        std::string userLDAPFilter;
        std::string userADAttribute;
        std::string userADFilter;
        std::string groupLDAPAttribute;
        std::string groupLDAPFilter;
        std::string groupADAttribute;
        std::string groupADFilter;
        std::string userADGroupAttribute;
        std::string userLDAPGroupAttribute;
        std::string userADEmailAttribute;
        std::string userLDAPEmailAttribute;
    public:
        MDispatcherConfigurationLDAP();

        bool getEnableBindings();
        int getServerType();
        int getEncryptionType();
        std::string getServerAddress();
        int getServerPort();
        std::string getBaseDN();
        std::string getGroupsBaseDN();
        std::string getBindDN();
        std::string getBindUsername();
        std::string getBindPassword();
        bool getUpdateAutomatically();
        int getUpdateResolution();

        std::string getUserLDAPAttribute();
        std::string getUserLDAPFilter();
        std::string getUserADAttribute();
        std::string getUserADFilter();
        std::string getGroupLDAPAttribute();
        std::string getGroupLDAPFilter();
        std::string getGroupADAttribute();
        std::string getGroupADFilter();
        std::string getUserADGroupAttribute();
        std::string getUserLDAPGroupAttribute();
        std::string getUserADEmailAttribute();
        std::string getUserLDAPEmailAttribute();

        void setEnableBindings(bool);
        void setServerType(int);
        void setEncryptionType(int);
        void setServerAddress(const std::string&);
        void setServerPort(int);
        void setBaseDN(const std::string&);
        void setGroupsBaseDN(const std::string&);
        void setBindDN(const std::string&);
        void setBindUsername(const std::string&);
        void setBindPassword(const std::string&);
        void setUpdateAutomatically(bool);
        void setUpdateResolution(int);

        void setUserLDAPAttribute(const std::string&);
        void setUserLDAPFilter(const std::string&);
        void setUserADAttribute(const std::string&);
        void setUserADFilter(const std::string&);
        void setGroupLDAPAttribute(const std::string&);
        void setGroupLDAPFilter(const std::string&);
        void setGroupADAttribute(const std::string&);
        void setGroupADFilter(const std::string&);
        void setUserADGroupAttribute(const std::string&);
        void setUserLDAPGroupAttribute(const std::string&);
        void setUserADEmailAttribute(const std::string&);
        void setUserLDAPEmailAttribute(const std::string&);

        bool Unmarshall(std::vector<std::string>& items);
        std::string Marshall();

    };
}

#endif