host/c%2B%2B/Host.cpp

#include <iostream.h>
#include <unistd.h> // linux header for the sleep function
#include <stdlib.h> // itoa()
#include <time.h>
#include "SysMon.h"
// #include "Config.h" - redefinition error - turns out i don't need it
#ifndef  XMLFORMATTER_H         /* Has the file been INCLUDE'd already? */
    #define  XMLFORMATTER_H  yes
    #include "XMLFormatter.h"
#endif

using std::string;

int main(){
        
        // list of local variables
        int noErrors = 1;
        int reloadConfig = 0;
        
        // print some extra info..
        int debug = 0;
        
        // create a new connection with the Config Host
        // values hard coded for the moment
        std::cout << "C Host starting..\n";
        
        std::cout << "Attemping to load config\n";
        Config config("raptor.ukc.ac.uk",4567,debug);           // host, port, debug (0/1)
        
        std::cout << "Creating data collector\n";
        SysMon sysMon(config, debug);
        
        std::cout << "Configuring UDPUpdateTime\n";
        int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
        if (  UDPUpdateTime == -1 ){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                        UDPUpdateTime = 5;
                } // if
        } // if
                        
                        
        std::cout << "Configuring TCPUpdateTime\n";
        int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
        if ( TCPUpdateTime  == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                        TCPUpdateTime = 10;
                } // if
        } // if
        
        std::cout << "Configuring AveragerUpdateTime\n";
        int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
        if ( AveragerUpdateTime == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default time!\n";
                } // if
                AveragerUpdateTime = 2;
        } // if
        
        std::cout << "Configuring Filter Retry Tolerances\n";
        int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
        if ( MaxFilterRetrys == -1){
                if ( debug == 1 ){
                        std::cout << "Using Default Tolerance\n";
                } // if
                MaxFilterRetrys = 1;
        } // if
        
        
        // std::cout << "Configuring Alerter\n";
        // Set the values at which the Alerter should kick in. and how many packets it should
        // send
        
        // now do the data collection
        
        std::cout << "Starting Data Collection\n";
        // work out which is closer, the next heartbeat or the next data collection
        int localTime = time(NULL);
        // std::cout << "#";
        int nextUDPTime = localTime + UDPUpdateTime;
        int nextAveragerTime = localTime + AveragerUpdateTime;
        int nextTCPTime = localTime + TCPUpdateTime;
        int sequence = 0;
                
        int nextAction = 0;
        while ( noErrors == 1){
                // firstly check we haven't got to reload our config
                if ( reloadConfig == 1 ){
                        // reload the config by starting a new
                        std::cout << "Forcing reload of Configuration\n";
                        config = Config("raptor.ukc.ac.uk",4567,debug);
                        
                        std::cout << "Configuring UDPUpdateTime\n";
                        int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
                        if (  UDPUpdateTime == -1 ){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                        UDPUpdateTime = 5;
                                } // if
                        } // if
                                        
                                        
                        std::cout << "Configuring TCPUpdateTime\n";
                        int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
                        if ( TCPUpdateTime  == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                        TCPUpdateTime = 10;
                                } // if
                        } // if
                        
                        std::cout << "Configuring AveragerUpdateTime\n";
                        int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
                        if ( AveragerUpdateTime == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default time!\n";
                                } // if
                                AveragerUpdateTime = 2;
                        } // if
                        
                        std::cout << "Configuring Filter Retry Tolerances\n";
                        int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
                        if ( MaxFilterRetrys == -1){
                                if ( debug == 1 ){
                                        std::cout << "Using Default Tolerance\n";
                                } // if
                                MaxFilterRetrys = 5;
                        } // if
                        // reloadConfig is done now
                        reloadConfig = 0;
                } // if reloadconfig
                
                
                
                localTime = time(NULL);
                // keep going while no non-fatal errors have occurred
                int waitTime = 0;
                
                if ( nextTCPTime  <= nextAveragerTime ){
                        if ( nextTCPTime >= nextUDPTime ){
                                nextAction = 3;
                                waitTime = nextUDPTime - localTime;
                        } else {
                                // set the heartbeat to be the next item
                                nextAction = 1;
                                waitTime = nextTCPTime - localTime;
                        } // if
                } else {
                        if ( nextAveragerTime >=  nextUDPTime ){
                                nextAction = 3;
                                waitTime = nextUDPTime - localTime;
                        } else {
                                // set grabstats to be in the next action
                                nextAction = 2;
                                waitTime = nextAveragerTime - localTime;
                        } // if
                } // if
                
                // sleep until this time only if it is greater than 1!
                if ( waitTime >= 1 ){
                        sleep(waitTime);
                        
                } 
                
                
                localTime = time(NULL);
                int con = -1;
                int conCount = 0;
                
                // do the action
                switch (nextAction){
                        case 1: std::cout << "Scheduled TCP Heartbeat Connection" << endl; 
                                nextTCPTime = localTime + TCPUpdateTime; 
                                // connect to the filter - should do all the talking within config.
                                con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());                             
                                conCount = 0;
                                while (( con != 0 ) && ( conCount < MaxFilterRetrys )){
                                        int con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());                          
                                        conCount++;
                                }
                                // if con != 0, then we must reconnect to the main filter manager and 
                                // reload our config!
                                if ( con == 0 ){
                                        // run the chat script
                                        int result = config.chatHeartBeat();
                                        if ( result != 0 ){
                                                // gotta reload our config
                                                reloadConfig = 1;
                                        } // if
                                } else {
                                        // set the config to be reloaded next time
                                        reloadConfig = 1;
                                } // if con =!= 0
                                
                                break;
                        case 2: nextAveragerTime = localTime + AveragerUpdateTime; 
                                /*
                                if ( sysMon.collect() > 0 ){
                                        // suggests that there should be an alert
                                        std::cout << "Alert Status" << endl;                                    
                                    }*/
                                break;
                        default: std::cout << "Scheduled UDP Connection" << endl; 
                             sysMon.collect();
                                 nextUDPTime = localTime + UDPUpdateTime; 
                                 // package up the system data
                                 string host = config.getFQDN();
                                 // string ip = (config.getSmallNet())->getHostIP();
                                 
                                 string seq = "";
                                 // char * buffer;
                                 char buffer[32];
                                 sprintf(buffer,"%u", sequence); 
                                 seq = buffer;
                                 string date = "";
                                 sprintf(buffer,"%u", localTime); 
                                 date = buffer;
                         string attributes = "type=\"data\" machine_name=\""+host+"\" ip=\"0.0.0.0\" date=\""+date+"\" seq_no=\""+seq+"\"";

                                 XMLFormatter xml("packet",attributes);
                                 // put in the data
                                 xml.addString(sysMon.getData());
                                 (config.getSmallNet())->sendUPDPacket(config.getUDPFilterName(), config.getUDPFilterPort(), xml.returnXML());
                                 // now clear the averaged data
                                 sysMon.clearData();
                                 sequence++;
                                 break;
                } // switch
                
        } // while
        
        std::cout << "A fatal error occurred which caused this program to quit\n";
        std::cout << "It is suggested that all belly button lint should be removed\n";
        std::cout << "prior to use of this program\n";
        std::cout << "Oh and BTW, All you BASE are belong to us!\n";
        std::cout << "Error Code: " << noErrors << "\n";
        
        return 0;
        
} // main
Revision:	1.5
Committed:	Tue Mar 27 00:05:47 2001 UTC (24 years, 7 months ago) by ab11
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION
Changes since 1.4:	+4 -4 lines
Log Message:	Cleaned up code and modified one or two bits
#	User	Rev	Content
1	ab11	1.1	#include <iostream.h>
2			#include <unistd.h> // linux header for the sleep function
3	ab11	1.2	#include <stdlib.h> // itoa()
4	ab11	1.1	#include <time.h>
5			#include "SysMon.h"
6			// #include "Config.h" - redefinition error - turns out i don't need it
7			#ifndef XMLFORMATTER_H /* Has the file been INCLUDE'd already? */
8			#define XMLFORMATTER_H yes
9			#include "XMLFormatter.h"
10			#endif
11
12			using std::string;
13
14			int main(){
15
16			// list of local variables
17			int noErrors = 1;
18	ab11	1.2	int reloadConfig = 0;
19	ab11	1.1
20			// print some extra info..
21			int debug = 0;
22
23			// create a new connection with the Config Host
24			// values hard coded for the moment
25			std::cout << "C Host starting..\n";
26
27			std::cout << "Attemping to load config\n";
28	ab11	1.2	Config config("raptor.ukc.ac.uk",4567,debug); // host, port, debug (0/1)
29	ab11	1.1
30			std::cout << "Creating data collector\n";
31			SysMon sysMon(config, debug);
32
33			std::cout << "Configuring UDPUpdateTime\n";
34			int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
35			if ( UDPUpdateTime == -1 ){
36			if ( debug == 1 ){
37			std::cout << "Using Default time!\n";
38			UDPUpdateTime = 5;
39			} // if
40			} // if
41
42	ab11	1.2
43	ab11	1.1	std::cout << "Configuring TCPUpdateTime\n";
44			int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
45			if ( TCPUpdateTime == -1){
46			if ( debug == 1 ){
47			std::cout << "Using Default time!\n";
48			TCPUpdateTime = 10;
49			} // if
50			} // if
51
52			std::cout << "Configuring AveragerUpdateTime\n";
53			int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
54			if ( AveragerUpdateTime == -1){
55			if ( debug == 1 ){
56			std::cout << "Using Default time!\n";
57			} // if
58			AveragerUpdateTime = 2;
59			} // if
60
61	ab11	1.2	std::cout << "Configuring Filter Retry Tolerances\n";
62			int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
63			if ( MaxFilterRetrys == -1){
64			if ( debug == 1 ){
65			std::cout << "Using Default Tolerance\n";
66			} // if
67	ab11	1.5	MaxFilterRetrys = 1;
68	ab11	1.2	} // if
69
70
71	ab11	1.5	// std::cout << "Configuring Alerter\n";
72	ab11	1.1	// Set the values at which the Alerter should kick in. and how many packets it should
73			// send
74
75			// now do the data collection
76
77	ab11	1.2	std::cout << "Starting Data Collection\n";
78	ab11	1.1	// work out which is closer, the next heartbeat or the next data collection
79	ab11	1.3	int localTime = time(NULL);
80	ab11	1.2	// std::cout << "#";
81	ab11	1.1	int nextUDPTime = localTime + UDPUpdateTime;
82			int nextAveragerTime = localTime + AveragerUpdateTime;
83			int nextTCPTime = localTime + TCPUpdateTime;
84	ab11	1.3	int sequence = 0;
85	ab11	1.2
86	ab11	1.1	int nextAction = 0;
87			while ( noErrors == 1){
88	ab11	1.2	// firstly check we haven't got to reload our config
89			if ( reloadConfig == 1 ){
90			// reload the config by starting a new
91			std::cout << "Forcing reload of Configuration\n";
92			config = Config("raptor.ukc.ac.uk",4567,debug);
93
94			std::cout << "Configuring UDPUpdateTime\n";
95			int UDPUpdateTime = config.getIntProperty("UDPUpdateTime");
96			if ( UDPUpdateTime == -1 ){
97			if ( debug == 1 ){
98			std::cout << "Using Default time!\n";
99			UDPUpdateTime = 5;
100			} // if
101			} // if
102
103
104			std::cout << "Configuring TCPUpdateTime\n";
105			int TCPUpdateTime = config.getIntProperty("TCPUpdateTime");
106			if ( TCPUpdateTime == -1){
107			if ( debug == 1 ){
108			std::cout << "Using Default time!\n";
109			TCPUpdateTime = 10;
110			} // if
111			} // if
112
113			std::cout << "Configuring AveragerUpdateTime\n";
114			int AveragerUpdateTime = config.getIntProperty("AVERAGERUpdateTime");
115			if ( AveragerUpdateTime == -1){
116			if ( debug == 1 ){
117			std::cout << "Using Default time!\n";
118			} // if
119			AveragerUpdateTime = 2;
120			} // if
121
122			std::cout << "Configuring Filter Retry Tolerances\n";
123			int MaxFilterRetrys = config.getIntProperty("MAXTCPFilterRetries");
124			if ( MaxFilterRetrys == -1){
125			if ( debug == 1 ){
126			std::cout << "Using Default Tolerance\n";
127			} // if
128			MaxFilterRetrys = 5;
129			} // if
130	ab11	1.3	// reloadConfig is done now
131			reloadConfig = 0;
132	ab11	1.2	} // if reloadconfig
133
134
135	ab11	1.3
136	ab11	1.2	localTime = time(NULL);
137	ab11	1.1	// keep going while no non-fatal errors have occurred
138			int waitTime = 0;
139
140			if ( nextTCPTime <= nextAveragerTime ){
141			if ( nextTCPTime >= nextUDPTime ){
142			nextAction = 3;
143	ab11	1.2	waitTime = nextUDPTime - localTime;
144	ab11	1.1	} else {
145			// set the heartbeat to be the next item
146			nextAction = 1;
147	ab11	1.2	waitTime = nextTCPTime - localTime;
148	ab11	1.1	} // if
149			} else {
150			if ( nextAveragerTime >= nextUDPTime ){
151			nextAction = 3;
152	ab11	1.2	waitTime = nextUDPTime - localTime;
153	ab11	1.1	} else {
154			// set grabstats to be in the next action
155			nextAction = 2;
156	ab11	1.2	waitTime = nextAveragerTime - localTime;
157	ab11	1.1	} // if
158			} // if
159
160			// sleep until this time only if it is greater than 1!
161			if ( waitTime >= 1 ){
162	ab11	1.4	sleep(waitTime);
163	ab11	1.2
164	ab11	1.1	}
165
166	ab11	1.2
167	ab11	1.1	localTime = time(NULL);
168	ab11	1.2	int con = -1;
169			int conCount = 0;
170
171	ab11	1.1	// do the action
172			switch (nextAction){
173	ab11	1.2	case 1: std::cout << "Scheduled TCP Heartbeat Connection" << endl;
174	ab11	1.1	nextTCPTime = localTime + TCPUpdateTime;
175	ab11	1.2	// connect to the filter - should do all the talking within config.
176			con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());
177			conCount = 0;
178			while (( con != 0 ) && ( conCount < MaxFilterRetrys )){
179			int con = (config.getSmallNet())->connectHeartBeat(config.getUDPFilterName(), config.getFilterPort());
180			conCount++;
181			}
182			// if con != 0, then we must reconnect to the main filter manager and
183			// reload our config!
184			if ( con == 0 ){
185			// run the chat script
186			int result = config.chatHeartBeat();
187			if ( result != 0 ){
188			// gotta reload our config
189			reloadConfig = 1;
190			} // if
191			} else {
192			// set the config to be reloaded next time
193			reloadConfig = 1;
194			} // if con =!= 0
195
196	ab11	1.1	break;
197	ab11	1.2	case 2: nextAveragerTime = localTime + AveragerUpdateTime;
198	ab11	1.4	/*
199	ab11	1.1	if ( sysMon.collect() > 0 ){
200			// suggests that there should be an alert
201	ab11	1.2	std::cout << "Alert Status" << endl;
202	ab11	1.4	}*/
203	ab11	1.1	break;
204	ab11	1.2	default: std::cout << "Scheduled UDP Connection" << endl;
205	ab11	1.4	sysMon.collect();
206	ab11	1.1	nextUDPTime = localTime + UDPUpdateTime;
207			// package up the system data
208	ab11	1.4	string host = config.getFQDN();
209	ab11	1.5	// string ip = (config.getSmallNet())->getHostIP();
210	ab11	1.2
211	ab11	1.3	string seq = "";
212			// char * buffer;
213			char buffer[32];
214			sprintf(buffer,"%u", sequence);
215			seq = buffer;
216			string date = "";
217			sprintf(buffer,"%u", localTime);
218			date = buffer;
219	ab11	1.5	string attributes = "type=\"data\" machine_name=\""+host+"\" ip=\"0.0.0.0\" date=\""+date+"\" seq_no=\""+seq+"\"";
220	ab11	1.1
221			XMLFormatter xml("packet",attributes);
222			// put in the data
223			xml.addString(sysMon.getData());
224			(config.getSmallNet())->sendUPDPacket(config.getUDPFilterName(), config.getUDPFilterPort(), xml.returnXML());
225	ab11	1.4	// now clear the averaged data
226			sysMon.clearData();
227	ab11	1.3	sequence++;
228	ab11	1.1	break;
229			} // switch
230
231			} // while
232
233			std::cout << "A fatal error occurred which caused this program to quit\n";
234			std::cout << "It is suggested that all belly button lint should be removed\n";
235	ab11	1.2	std::cout << "prior to use of this program\n";
236			std::cout << "Oh and BTW, All you BASE are belong to us!\n";
237	ab11	1.1	std::cout << "Error Code: " << noErrors << "\n";
238
239			return 0;
240
241	ab11	1.3	} // main