MNodeConfiguration.h
1 /*****************************************************************************
2  **
3  ** Header file for Muster API node configuration object
4  **
5  ** Name : MNodeConfiguration.h
6  ** Author : Leonardo Bernardini
7 ** Version : Alpha 9.0 Wed May 17th 2017
8  **
9  ** Copyright 2000-2017, Virtual Vertex
10  ** All Rights Reserved.
11  **
12  ** This file contains UNPUBLISHED PROPRIETARY SOURCE CODE.
13  ** The contents of this file may not be disclosed to third parties, copied
14  ** or duplicated in any form, in whole or in part, without the prior written
15  ** permission of the author.
16  **
17  *****************************************************************************/
18 #ifndef MNODECONFIGURATION_H
19 #define MNODECONFIGURATION_H
20 
21 #ifdef WIN32
22 // Windows definitions
23 #ifdef MCLIENTLIB_EXPORTS
24 #define MCLIENTLIB_API __declspec(dllexport)
25 #else
26 #define MCLIENTLIB_API __declspec(dllimport)
27 #endif
28 #else
29 
30 #ifndef MCLIENTLIB_EXPORTS
31 #ifdef LINUX
32 #define MCLIENTLIB_API
33 #else
34 #define MCLIENTLIB_API
35 #endif
36 #else
37 #define MCLIENTLIB_API
38 #endif
39 #endif
40 
41 #if defined(_WIN32)
42 #pragma warning(disable: 4251)
43 #pragma warning(disable: 4503)
44 #endif // _WIN32
45 
46 #include <MClientLib/MError.h>
47 #include <MClientLib/MDriveMap.h>
48 #include <MClientLib/MTimeRule.h>
49 #include <MClientLib/MTemplateVariable.h>
50 #include <MClientLib/MPriorityOverride.h>
51 #include <MClientLib/MRepository.h>
52 #include <MClientLib/MStringRef.h>
53 
54 #include <map>
55 
56 namespace MClientLib {
57 
68  class MCLIENTLIB_API MNodeConfigurationTuning {
69  private:
70  int garbageCollectorTTL;
71  int idlingScriptingTime;
72  int poolingEvents;
73 
74  public:
75  MNodeConfigurationTuning();
76  virtual ~MNodeConfigurationTuning();
77  virtual int getIdlingScriptingTime();
78  virtual int getGarbageCollectorTTL();
79  virtual int getPoolingEvents();
80 
81  virtual void setIdlingScriptingTime(int);
82  virtual void setGarbageCollectorTTL(int);
83  virtual void setPoolingEvents(int) ;
84 
85  };
86 
92  class MCLIENTLIB_API MNodeConfigurationBehaviours {
93  private:
94  int numberOfInstances;
95  int defaultNodePriority;
96  std::vector<MClientLib::MPriorityOverride> prioritiesOverrides;
97  bool startPaused, retainInstanceStatus;
98  int defaultProcessPriority;
99  int processesStartTimeout;
100  int loadSamplingResolution;
101  bool killActivityOnConnectionDrop;
102  bool changePriorityOnProcessTree;
103  bool terminateProcessesTrees;
104  bool suppressErrorChecking;
105  bool useSigTermOnUnix;
106  bool addMusterEnvironmentToProcesses;
107  bool addMusterEnvironmentToActions;
108  std::string shutdownCommand;
109  std::string restartCommand;
110  std::string forceLogoutCommand;
111  std::string suspendCommand;
112  std::string ibernateCommand;
113  bool blockSystemSleep;
114  public:
115  MNodeConfigurationBehaviours();
116  virtual ~MNodeConfigurationBehaviours();
117  virtual int getNumberOfInstances();
118  virtual int getDefaultNodePriority();
119  virtual std::vector<MClientLib::MPriorityOverride> getPrioritiesOverrides();
120  virtual bool getStartPaused();
121  virtual bool getRetainInstanceStatus();
122  virtual int getDefaultProcessPriority();
123  virtual int getProcessesStartTimeout();
124  virtual bool getKillActivityOnConnectionDrop();
125  virtual bool getChangePriorityOnProcessTree();
126  virtual bool getTerminateProcessesTrees();
127  virtual bool getSuppressErrorChecking();
128  virtual bool getUseSigTermOnUnix();
129  virtual bool getAddMusterEnvironmentToProcesses();
130  virtual bool getAddMusterEnvironmentToActions();
131  virtual std::string getShutdownCommand();
132  virtual std::string getRestartCommand();
133  virtual std::string getForceLogoutCommand();
134  virtual std::string getSuspendCommand();
135  virtual std::string getIbernateCommand();
136  virtual bool getBlockSystemSleep();
137 
138  virtual void setNumberOfInstances(int);
139  virtual void setDefaultNodePriority(int);
140  virtual void setPrioritiesOverrides(const std::vector<MClientLib::MPriorityOverride>& );
141  virtual void setStartPaused(bool);
142  virtual void setRetainInstanceStatus(bool);
143  virtual void setDefaultProcessPriority(int);
144  virtual void setProcessesStartTimeout(int);
145  virtual void setKillActivityOnConnectionDrop(bool);
146  virtual void setChangePriorityOnProcessTree(bool);
147  virtual void setTerminateProcessesTrees(bool);
148  virtual void setSuppressErrorChecking(bool);
149  virtual void setUseSigTermOnUnix(bool);
150  virtual void setAddMusterEnvironmentToProcesses(bool);
151  virtual void setAddMusterEnvironmentToActions(bool);
152 
153  virtual void setShutdownCommand( const std::string command);
154  virtual void setRestartCommand(const std::string command);
155  virtual void setForceLogoutCommand(const std::string command);
156  virtual void setSuspendCommand(const std::string command);
157  virtual void setIbernateCommand(const std::string command);
158  virtual void setBlockSystemSleep(bool);
159 
160  };
161 
165  class MCLIENTLIB_API MNodeConfigurationLogs {
166  private:
167  std::string processesLogsFolder;
168  int activityLogsSeverity;
169  std::string activityLogsFolder;
170  bool clearActivityLogsOlderThan;
171  int clearActivityLogsOlderThanDays;
172  bool clearActivityLogsExceeds;
173  int clearActivityLogsExceedsMB;
174  bool clearProcessesLogsOlderThan;
175  int clearProcessesLogsOlderThanDays;
176  bool clearProcessesLogsExceeds;
177  int clearProcessesLogsExceedsMB;
178  bool rescanLogFileSystem;
179  int rescanLogFileSystemSeconds;
180  int pythonLogMode;
181  bool enableProcessesLogsOnSharedFolder;
182  bool activityLogsGZip;
183  bool processLogsGZip;
184  int maximumWarnings;
185  int maximumErrors;
186  int maximumLineSize;
187  public:
188  MNodeConfigurationLogs();
189  virtual ~MNodeConfigurationLogs();
190  virtual std::string getProcessesLogsFolder();
191  virtual int getActivityLogsSeverity();
192  virtual std::string getActivityLogsFolder();
193  virtual bool getClearActivityLogsOlderThan();
194  virtual int getClearActivityLogsOlderThanDays();
195  virtual bool getClearActivityLogsExceeds();
196  virtual int getClearActivityLogsExceedsMB();
197  virtual bool getClearProcessesLogsOlderThan();
198  virtual int getClearProcessesLogsOlderThanDays();
199  virtual bool getClearProcessesLogsExceeds();
200  virtual int getClearProcessesLogsExceedsMB();
201  virtual bool getRescanLogFileSystem();
202  virtual int getRescanLogFileSystemSeconds();
203  virtual int getPythonLogMode();
204  virtual bool getEnableProcessesLogsOnSharedFolder();
205  virtual bool getActivityLogsGzip();
206  virtual bool getProcessLogsGzip();
207  virtual int getMaximumWarnings();
208  virtual int getMaximumErrors();
209  virtual int getMaximumLineSize();
210 
211  virtual void setProcessesLogsFolder(const std::string&);
212  virtual void setActivityLogsSeverity(int);
213  virtual void setActivityLogsFolder(const std::string&);
214  virtual void setClearActivityLogsOlderThan(bool);
215  virtual void setClearActivityLogsOlderThanDays(int);
216  virtual void setClearActivityLogsExceeds(bool);
217  virtual void setClearActivityLogsExceedsMB(int);
218  virtual void setClearProcessesLogsOlderThan(bool);
219  virtual void setClearProcessesLogsOlderThanDays(int);
220  virtual void setClearProcessesLogsExceeds(bool);
221  virtual void setClearProcessesLogsExceedsMB(int);
222  virtual void setRescanLogFileSystem(bool);
223  virtual void setRescanLogFileSystemSeconds(int);
224  virtual void setPythonLogMode(int);
225  virtual void setEnableProcessesLogsOnSharedFolder(bool);
226  virtual void setActivityLogsGzip(bool);
227  virtual void setProcessLogsGzip(bool);
228  virtual void setMaximumWarnings(int);
229  virtual void setMaximumErrors(int);
230  virtual void setMaximumLineSize(int);
231 
232  };
233 
237  class MCLIENTLIB_API MNodeConfigurationNetwork {
238  private:
239 
240  std::string dispatcherAddress;
241  int dispatcherPort;
242  int connectionResolution;
243  int managementPort;
244  bool enableHeartbeat;
245  int enableHeartbeatResolution;
246  bool broadcastPresence;
247  int broadcastPresenceIPVersion;
248  int broadcastResolution;
249  int usageResolution;
250  bool protectedManagement;
251  std::string managementPassword;
252  std::string impersonationUsername;
253  std::string impersonationPassword;
254  bool impersonationUseShell;
255  std::string hostName;
256  std::string managementBindingAddress;
257  int networkIncomingBuffer;
258  int networkOutgoingBuffer;
259 
260 
261  public:
262  MNodeConfigurationNetwork();
263  virtual ~MNodeConfigurationNetwork();
264  virtual std::string getDispatcherAddress();
265  virtual int getDispatcherPort();
266  virtual int getConnectionResolution();
267  virtual int getManagementPort();
268  virtual bool getEnableHeartbeat();
269  virtual int getEnableHeartbeatResolution();
270  virtual bool getBroadcastPresence();
271  virtual int getBroadcastPresenceIPVersion();
272  virtual int getUsageResolution();
273  virtual void setUsageResolution(int);
274  virtual int getBroadcastResolution();
275  virtual bool getProtectedManagement();
276  virtual std::string getManagementPassword();
277  virtual std::string getImpersonationUsername();
278  virtual std::string getImpersonationPassword();
279  virtual bool getImpersonationUseShell();
280  virtual std::string getHostName();
281  virtual std::string getManagementBindingAddress();
282  virtual int getNetworkIncomingBuffer();
283  virtual int getNetworkOutgoingBuffer();
284 
285  virtual void setDispatcherAddress(const std::string&);
286  virtual void setDispatcherPort(int);
287  virtual void setConnectionResolution(int);
288  virtual void setManagementPort(int);
289  virtual void setEnableHeartbeat(bool);
290  virtual void setEnableHeartbeatResolution(int);
291  virtual void setBroadcastPresence(bool);
292  virtual void setBroadcastPresenceIPVersion(int);
293  virtual void setBroadcastResolution(int);
294  virtual void setProtectedManagement(bool);
295  virtual void setManagementPassword(const std::string&);
296  virtual void setImpersonationUsername(const std::string&);
297  virtual void setImpersonationPassword(const std::string&);
298  virtual void setImpersonationUseShell(bool);
299  virtual void setHostName(const std::string&);
300  virtual void setManagementBindingAddress(const std::string&);
301  virtual void setNetworkIncomingBuffer(int);
302  virtual void setNetworkOutgoingBuffer(int);
303 
304 
305  };
306 
310  class MCLIENTLIB_API MNodeConfigurationMappingsAndPaths {
311  private:
312  bool enableNTAutomapping;
313  int automappingDisconnectionPolicy;
314  std::vector<MClientLib::MDriveMap> driveMappings;
315  std::string localRepositories;
316  public:
317  MNodeConfigurationMappingsAndPaths();
318  virtual ~MNodeConfigurationMappingsAndPaths();
319  virtual bool getEnableNTAutomapping();
320  virtual int getAutomappingDisconnectionPolicy();
321  virtual std::vector<MClientLib::MDriveMap> getDriveMappings();
322  virtual std::string getLocalRepositories();
323 
324  virtual void setEnableNTAutomapping(bool);
325  virtual void setAutomappingDisconnectionPolicy(int);
326  virtual void setDriveMappings(const std::vector<MClientLib::MDriveMap>&);
327  virtual void setLocalRepositories(const std::string&);
328  };
329 
333  class MCLIENTLIB_API MNodeConfigurationAvailability {
334  private:
335  std::vector<MClientLib::MTimeRule> timeRules;
336  bool checkLogin;
337  bool checkLoginRemote;
338  bool checkLoginWaitProcessTermination;
339  bool enableScreensaverControl;
340  bool enableRunningProcessesCheck;
341  bool enableNotRunningProcessesCheck;
342  std::string runningProcessesCheck;
343  std::string notRunningProcessesCheck;
344  bool timeRuleAvailableByDefault;
345  bool onTimeRuleWaitProcessTermination;
346  bool timeRuleAvailableOnPowerSavingStates;
347  public:
348  MNodeConfigurationAvailability();
349  virtual ~MNodeConfigurationAvailability();
350 
351  virtual std::vector<MClientLib::MTimeRule> getTimeRules();
352  virtual bool getCheckLogin();
353  virtual bool getCheckLoginRemote();
354  virtual bool getCheckLoginWaitProcessTermination();
355  virtual bool getEnableScreensaverControl();
356  virtual bool getEnableRunningProcessesCheck();
357  virtual bool getEnableNotRunningProcessesCheck();
358  virtual std::string getRunningProcessesCheck();
359  virtual std::string getNotRunningProcessesCheck();
360  virtual bool getTimeRuleAvailableByDefault();
361  virtual bool getOnTimeRuleWaitProcessTermination();
362  virtual bool getTimeRuleAvailableOnPowerSavingStates();
363 
364  virtual void setTimeRules(const std::vector<MClientLib::MTimeRule>& );
365  virtual void setCheckLogin(bool);
366  virtual void setCheckLoginRemote(bool);
367  virtual void setCheckLoginWaitProcessTermination(bool);
368  virtual void setEnableScreensaverControl(bool);
369  virtual void setEnableRunningProcessesCheck(bool);
370  virtual void setEnableNotRunningProcessesCheck(bool);
371  virtual void setRunningProcessesCheck(const std::string&);
372  virtual void setNotRunningProcessesCheck(const std::string&);
373  virtual void setTimeRuleAvailableByDefault(bool);
374  virtual void setOnTimeRuleWaitProcessTermination(bool);
375  virtual void setTimeRuleAvailableOnPowerSavingStates(bool);
376  };
377 
381  class MCLIENTLIB_API MNodeConfigurationShutdown {
382  private:
383  std::vector<MClientLib::MTimeRule> shutdownRules;
384  bool shutdownWithNoUsers;
385  bool shutdownTrackRemoteLogins;
386  bool shutdownWhenIdle;
387  int shutdownWhenIdleMinutes;
388  bool shutdownWhenPaused;
389  int shutdownWhenPausedMinutes;
390  int shutdownAction;
391  bool shutdownRulesMatchAvailability;
392  int onUserLogoutShutdownTimeout;
393  public:
394  MNodeConfigurationShutdown();
395  virtual ~MNodeConfigurationShutdown();
396 
397  virtual std::vector<MClientLib::MTimeRule> getShutdownRules();
398  virtual bool getShutdownWithNoUsers();
399  virtual bool getShutdownTrackRemoteLogins();
400  virtual bool getShutdownWhenIdle();
401  virtual int getShutdownWhenIdleMinutes();
402  virtual bool getShutdownWhenPaused();
403  virtual int getShutdownWhenPausedMinutes();
404  virtual int getShutdownAction();
405  virtual bool getShutdownRulesMatchAvailability();
406  virtual int getOnUserLogoutShutdownTimeout();
407 
408  virtual void setShutdownRules(const std::vector<MClientLib::MTimeRule>& );
409  virtual void setShutdownWithNoUsers(bool);
410  virtual void setShutdownTrackRemoteLogins(bool);
411  virtual void setShutdownWhenIdle(bool);
412  virtual void setShutdownWhenIdleMinutes(int);
413  virtual void setShutdownWhenPaused(bool);
414  virtual void setShutdownWhenPausedMinutes(int);
415  virtual void setShutdownAction(int);
416  virtual void setShutdownRulesMatchAvailability(bool);
417  virtual void setOnUserLogoutShutdownTimeout(int);
418  };
419 
423  class MCLIENTLIB_API MNodeConfigurationWakeup {
424  private:
425  std::vector<MClientLib::MTimeRule> wakeupRules;
426  bool wakeupRulesMatchAvailability;
427  bool wakeupAtFullLoad;
428  bool wakeupWhenRequiredByPool;
429  public:
430  MNodeConfigurationWakeup();
431  virtual ~MNodeConfigurationWakeup();
432 
433  virtual std::vector<MClientLib::MTimeRule> getWakeupRules();
434  virtual bool getWakeupRulesMatchAvailability();
435  virtual bool getWakeupAtFullLoad();
436  virtual bool getWakeupWhenRequiredByPool();
437 
438  virtual void setWakeupRules(const std::vector<MClientLib::MTimeRule>& );
439  virtual void setWakeupRulesMatchAvailability(bool);
440  virtual void setWakeupAtFullLoad(bool);
441  virtual void setWakeupWhenRequiredByPool(bool);
442  };
443 
447  class MCLIENTLIB_API MNodeConfigurationAlarms {
448  private:
449 
450  public:
451  MNodeConfigurationAlarms();
452  virtual ~MNodeConfigurationAlarms();
453 
454  virtual bool getRaiseAlarmWhenProcDropsBelow();
455  virtual int getProcDropsBelowPercent();
456  virtual int getProcDropsBelowThreshold();
457  virtual bool getRaiseAlarmWhenProcOver();
458  virtual int getProcOverPercent();
459  virtual int getProcOverThreshold();
460  virtual bool getRaiseAlarmWhenInstanceProcDropsBelow();
461  virtual int getInstanceProcDropsBelowPercent();
462  virtual int getInstanceProcDropsBelowThreshold();
463  virtual bool getRaiseAlarmWhenInstanceProcOver();
464  virtual int getInstanceProcOverPercent();
465  virtual int getInstanceProcOverThreshold();
466 
467  virtual bool getRaiseAlarmWhenRamUsageIsOver();
468  virtual bool getRaiseAlarmWhenProcRamUsageIsOver();
469  virtual bool getRaiseAlarmWhenSwapUsageIsOver();
470  virtual bool getRaiseAlarmWhenDiskUsageIsOver();
471  virtual int getRamUsageOverPercent();
472  virtual int getProcRamUsageOverPercent();
473  virtual int getSwapUsageOverPercent();
474  virtual int getDiskUsageOverPercent();
475 
476  virtual void setRaiseAlarmWhenProcDropsBelow(bool _raiseAlarmWhenProcDropsBelow);
477  virtual void setProcDropsBelowPercent(int _procDropsBelowPercent);
478  virtual void setProcDropsBelowThreshold(int _procDropsBelowThreshold);
479  virtual void setRaiseAlarmWhenProcOver(bool _raiseAlarmWhenProcOver);
480  virtual void setProcOverPercent(int _procOverPercent);
481  virtual void setProcOverThreshold(int _procOverThreshold);
482  virtual void setRaiseAlarmWhenInstanceProcDropsBelow(bool _raiseAlarmWhenInstanceProcDropsBelow);
483  virtual void setInstanceProcDropsBelowPercent(int _instanceProcDropsBelowPercent);
484  virtual void setInstanceProcDropsBelowThreshold(int _instanceProcDropsBelowThreshold);
485  virtual void setRaiseAlarmWhenInstanceProcOver(bool _raiseAlarmWhenInstanceProcOver);
486  virtual void setInstanceProcOverPercent(int _instanceProcOverPercent);
487  virtual void setInstanceProcOverThreshold(int _instanceProcOverThreshold);
488 
489  virtual void setRaiseAlarmWhenRamUsageIsOver(bool _raiseAlarmWhenRamUsageIsOver);
490  virtual void setRaiseAlarmWhenProcRamUsageIsOver(bool _raiseAlarmWhenRamUsageIsOver);
491  virtual void setRaiseAlarmWhenSwapUsageIsOver(bool _raiseAlarmWhenSwapUsageIsOver);
492  virtual void setRaiseAlarmWhenDiskUsageIsOver(bool _raiseAlarmWhenDiskUsageIsOver);
493  virtual void setRamUsageOverPercent(int _ramUsageOverPercent);
494  virtual void setProcRamUsageOverPercent(int _procRamUsageOverPercent);
495  virtual void setSwapUsageOverPercent(int _swapUsageOverPercent);
496  virtual void setDiskUsageOverPercent(int _diskUsageOverPercent);
497 
498  private:
499 
500  bool raiseAlarmWhenProcDropsBelow;
501  int procDropsBelowPercent;
502  int procDropsBelowThreshold;
503 
504  bool raiseAlarmWhenProcOver;
505  int procOverPercent;
506  int procOverThreshold;
507 
508  bool raiseAlarmWhenInstanceProcDropsBelow;
509  int instanceProcDropsBelowPercent;
510  int instanceProcDropsBelowThreshold;
511 
512  bool raiseAlarmWhenInstanceProcOver;
513  int instanceProcOverPercent;
514  int instanceProcOverThreshold;
515 
516  bool raiseAlarmWhenRamUsageIsOver;
517  bool raiseAlarmWhenProcRamUsageIsOver;
518  bool raiseAlarmWhenSwapUsageIsOver;
519  bool raiseAlarmWhenDiskUsageIsOver;
520 
521  int ramUsageOverPercent;
522  int procRamUsageOverPercent;
523  int swapUsageOverPercent;
524  int diskUsageOverPercent;
525 
526  };
527 
531  class MCLIENTLIB_API MNodeConfiguration {
532  private:
533  typedef std::map< std::string, MClientLib::MTemplateVariable> MNodeConfigurationVariableType;
534  typedef std::map< std::string, MNodeConfigurationVariableType > MNodeConfigurationVersionType;
535  typedef std::map< int, MNodeConfigurationVersionType > MNodeConfigurationTemplateType;
536  MNodeConfigurationTemplateType templatesVariables;
537  public:
538 
539  MNodeConfiguration();
540  virtual ~MNodeConfiguration();
541  MNodeConfigurationWakeup* wakeup;
542  MNodeConfigurationShutdown* shutdown;
543  MNodeConfigurationAvailability* availability;
544  MNodeConfigurationMappingsAndPaths* mappingsAndPaths;
545  MNodeConfigurationNetwork* network;
546  MNodeConfigurationLogs* logs;
547  MNodeConfigurationBehaviours* behaviours;
548  MNodeConfigurationTuning* tuning;
549  MNodeConfigurationAlarms* alarms;
550  virtual void clearTemplatesVariables();
551  virtual std::vector<MClientLib::MTemplateVariable> getTemplatesVariables();
552  virtual void setTemplatesVariables(std::vector<MClientLib::MTemplateVariable>& );
553  virtual void setTemplateVariable(int templateId, const std::string& version, const std::string& _key, const std::string& value);
554  virtual bool getTemplateVariable(int templateId, const std::string& version, const std::string& _key, MClientLib::MStringRef& result);
556  virtual bool Unmarshall(const std::vector<std::string>& items);
557  virtual std::string Marshall();
560  };
561 
563 }
564 
565 #endif
MClientLib::MStringRef
Class holding a string used across the API.
Definition: MStringRef.h:60
MClientLib::MNodeConfigurationTuning
Class holding a node tuning configurations data.
Definition: MNodeConfiguration.h:68
MClientLib::MNodeConfigurationBehaviours
Class holding a node behaviours configurations data.
Definition: MNodeConfiguration.h:92