ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/idar/idar.c

Comparing projects/cms/source/idar/idar.c (file contents):
Revision 1.5 by pajs, Sun Mar 30 10:58:21 2003 UTC vs.
Revision 1.12 by pajs, Thu Apr 3 10:59:28 2003 UTC

#	Line 29 | Line 29
29		#include <unistd.h>
30		#include <stdlib.h>
31		#include <ukcprog.h>
32	+	#include <netinet/in.h>
33	+	#include <netdb.h>
34
35		#include <libxml/xmlmemory.h>
36		#include <libxml/parser.h>
37		#include "genmergesort.h"
38	+
39	+	#ifdef HAVE_NCURSES_H
40	+	#include <ncurses.h>
41	+	#else
42		#include <curses.h>
43	+	#endif
44
45		struct host_line_t{
46		char *hostname;
#	Line 117 | Line 124 | struct machine_data_t{
124		network_data_list_t *network_data_list;
125		long long network_io_total_tx;
126		long long network_io_total_rx;
127	+	long long network_io_total;
128
129		diskio_data_list_t *diskio_data_list;
130		long long disk_io_total_write;
131		long long disk_io_total_read;
132	+	long long disk_io_total;
133
134		/* Maybe in the future */
135		/*
#	Line 133 | Line 142 | struct machine_data_t{
142
143		typedef struct machine_data_t machine_data_list_t;
144
145	+	#define SORTBYMAXNAME 128
146		typedef struct{
147		int cpu_user;
148		int cpu_idle;
#	Line 174 | Line 184 | typedef struct{
184
185		int disk_total_used;
186		int disk_all_stats;
187	+
188	+	char sortby[SORTBYMAXNAME];
189		}display_config_t;
190
191		GENERIC_MERGE_SORT(static, sort_machine_stats, machine_data_list_t, next)
#	Line 185 | Line 197 | int (*sortby_ptr)(machine_data_list_t *a, machine_data
197
198		MKCMP(cpu_used)
199		MKCMP(load_1)
200	+	MKCMP(network_io_total)
201		MKCMP(network_io_total_tx)
202		MKCMP(network_io_total_rx)
203	+	MKCMP(disk_io_total)
204		MKCMP(disk_io_total_write)
205		MKCMP(disk_io_total_read)
206		MKCMP(memory_used_pecent)
207		MKCMP(swap_used_pecent)
208
209	+	#define CPU_USED "CPU used"
210	+	#define LOAD "Load (1)"
211	+	#define NETIORX "total Network RX for all interfaces"
212	+	#define NETIOTX "total Network TX for all interfaces"
213	+	#define NETIO "total Network IO for all interfaces (rx+tx)"
214	+	#define MEM "Memory usage"
215	+	#define SWAP "Swap usage"
216	+	#define DISKIOR "DiskIO reads"
217	+	#define DISKIOW "DiskIO writes"
218	+	#define DISKIO "Total DiskIO (reads+writes)"
219	+
220	+
221		/*
222		int cmp_cpu(machine_data_list_t *a, machine_data_list_t *b){
223
#	Line 211 | Line 237 | int cmp_cpu(machine_data_list_t *a, machine_data_list_
237		}
238		}
239		*/
240	+
241	+	#ifndef HAVE_ATOLL
242	+	long long int atoll (const char *nptr){
243	+	return strtoll (nptr, (char **) NULL, 10);
244	+	}
245	+	#endif
246	+
247	+	#ifndef HAVE_STRLCPY
248	+	/*
249	+	* Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
250	+	* All rights reserved.
251	+	*
252	+	* Redistribution and use in source and binary forms, with or without
253	+	* modification, are permitted provided that the following conditions
254	+	* are met:
255	+	* 1. Redistributions of source code must retain the above copyright
256	+	*    notice, this list of conditions and the following disclaimer.
257	+	* 2. Redistributions in binary form must reproduce the above copyright
258	+	*    notice, this list of conditions and the following disclaimer in the
259	+	*    documentation and/or other materials provided with the distribution.
260	+	* 3. The name of the author may not be used to endorse or promote products
261	+	*    derived from this software without specific prior written permission.
262	+	*
263	+	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
264	+	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
265	+	* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
266	+	* THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
267	+	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
268	+	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
269	+	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
270	+	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
271	+	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
272	+	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
273	+	*/
274	+
275	+	/*
276	+	* Copy src to string dst of size siz.  At most siz-1 characters
277	+	* will be copied.  Always NUL terminates (unless siz == 0).
278	+	* Returns strlen(src); if retval >= siz, truncation occurred.
279	+	*/
280	+	size_t
281	+	strlcpy(dst, src, siz)
282	+	char *dst;
283	+	const char *src;
284	+	size_t siz;
285	+	{
286	+	register char *d = dst;
287	+	register const char *s = src;
288	+	register size_t n = siz;
289	+
290	+	/* Copy as many bytes as will fit */
291	+	if (n != 0 && --n != 0) {
292	+	do {
293	+	if ((*d++ = *s++) == 0)
294	+	break;
295	+	} while (--n != 0);
296	+	}
297	+
298	+	/* Not enough room in dst, add NUL and traverse rest of src */
299	+	if (n == 0) {
300	+	if (siz != 0)
301	+	*d = '\0';              /* NUL-terminate dst */
302	+	while (*s++)
303	+	;
304	+	}
305	+
306	+	return(s - src - 1);    /* count does not include NUL */
307	+	}
308	+
309	+	#endif
310	+
311
312		FILE *create_tcp_connection(char *hostname, int port){
313		int sock;
#	Line 559 | Line 656 | int parse_xml(char *xml, machine_data_list_t **md){
656		machine_data_list->network_io_total_rx+=ndl_ptr->rx;
657		ndl_ptr=ndl_ptr->next;
658		}
659	+	machine_data_list->network_io_total=machine_data_list->network_io_total_rx+machine_data_list->network_io_total_tx;
660
661		didl_ptr=machine_data_list->diskio_data_list;
662		machine_data_list->disk_io_total_read=0;
#	Line 568 | Line 666 | int parse_xml(char *xml, machine_data_list_t **md){
666		machine_data_list->disk_io_total_write+=didl_ptr->write;
667		didl_ptr=didl_ptr->next;
668		}
669	+	machine_data_list->disk_io_total=machine_data_list->disk_io_total_read+machine_data_list->disk_io_total_write;
670
671		xmlFreeDoc(doc);
672
#	Line 578 | Line 677 | int parse_xml(char *xml, machine_data_list_t **md){
677
678		void display(machine_data_list_t *machine_data_list, display_config_t *display_config, int num_lines, int *title){
679		int line_num=4;
680	+	int counter;
681		int x=1;
682
683		if(*title){
684	<	//              printf("\033[2J");
685	<	//      printf("\033[1;1HHostname     CPU   Load  Page  Page  Mem   Swap      Net      Net      Disk     Disk");
686	<	//       printw("\033[2;1H             used%% (1m)  ins   outs  used  used      rx       tx       read     write");
684	>	clear();
685	>	move (num_lines-3, 1);
686	>	printw("Sorting by %-64s", display_config->sortby);
687	>
688		move(1,1);
689		printw("%-11s", "Hostname");
690		x=x+11+1;
#	Line 661 | Line 762 | void display(machine_data_list_t *machine_data_list, d
762		*title=0;
763		}
764
765	<	for(;num_lines;num_lines--){
765	>	/* Counter starts at 8, for padding (eg, headers, borders etc) */
766	>	for(counter=8;counter<num_lines;counter++){
767		if(machine_data_list==NULL) break;
768		move(line_num++, 1);
769		printw("%-11s", machine_data_list->sysname);
#	Line 688 | Line 790 | void display(machine_data_list_t *machine_data_list, d
790		int main(int argc, char **argv){
791		WINDOW *window;
792		fd_set infds;
793	+	int maxx, maxy;
794
795		FILE *control;
796		FILE *data;
#	Line 703 | Line 806 | int main(int argc, char **argv){
806
807		int num_hosts;
808		int max_display=0;
809	<	int title;
809	>	int title=1;
810
811		int cmdopt;
812		extern int optind;
#	Line 749 | Line 852 | int main(int argc, char **argv){
852
853		display_config.network_io_total_tx=1;
854		display_config.network_io_total_rx=1;
855	<	display_config.network_all_stats=1;
855	>	display_config.network_all_stats=0;
856
857	<	display_config.disk_io_total_write=0;
858	<	display_config.disk_io_total_read=0;
857	>	display_config.disk_io_total_write=1;
858	>	display_config.disk_io_total_read=1;
859		display_config.disk_io_all_stats=0;
860
861		display_config.disk_total_used=0;
#	Line 766 | Line 869 | int main(int argc, char **argv){
869		case 's':
870		if(!strcmp(optarg, "cpu")){
871		sortby_ptr=cmp_cpu_used;
872	+	strlcpy(display_config.sortby, CPU_USED, SORTBYMAXNAME);
873		}
874		if(!strcmp(optarg, "load")){
875		sortby_ptr=cmp_load_1;
876	+	strlcpy(display_config.sortby, LOAD, SORTBYMAXNAME);
877		}
878		if(!strcmp(optarg, "mem")){
879		sortby_ptr=cmp_memory_used_pecent;
880	+	strlcpy(display_config.sortby, MEM, SORTBYMAXNAME);
881		}
882	+	if(!strcmp(optarg, "swap")){
883	+	sortby_ptr=cmp_swap_used_pecent;
884	+	strlcpy(display_config.sortby, SWAP, SORTBYMAXNAME);
885	+	}
886		if(sortby_ptr==NULL){
887		errf("Invalid sort type");
888		exit(1);
#	Line 781 | Line 891 | int main(int argc, char **argv){
891		}
892		}
893
894	<	if(sortby_ptr==NULL) sortby_ptr=cmp_cpu_used;
894	>	if(sortby_ptr==NULL){
895	>	sortby_ptr=cmp_cpu_used;
896	>	strlcpy(display_config.sortby, "CPU Used", SORTBYMAXNAME);
897	>	}
898
899		if(argc<(optind+2)){
900		printf("Usage is %s <-d lines> hostname port <machine list>\n", argv[0]);
#	Line 794 | Line 907 | int main(int argc, char **argv){
907		control=create_tcp_connection(servername, server_control_port);
908		if(control==NULL){
909		errf("Failed to connect (%m)");
910	+	exit(1);
911		}
912
913		if(argc==4){
#	Line 850 | Line 964 | int main(int argc, char **argv){
964		cbreak();
965		echo();
966		window=newwin(0, 0, 0, 0);
967	+	getmaxyx(window, maxy, maxx);
968
969		stdin_fileno=fileno(stdin);
970		data_fileno=fileno(data);
971		biggest_fileno=(data_fileno>stdin_fileno) ? (data_fileno+1) : (stdin_fileno+1);
972	<
972	>
973		for(;;){
974		FD_ZERO(&infds);
975		FD_SET(stdin_fileno, &infds);
#	Line 864 | Line 979 | int main(int argc, char **argv){
979		if(FD_ISSET(stdin_fileno, &infds)){
980
981		ch=getc(stdin);
982	+	switch(ch){
983
984	<	if(ch=='q'){
985	<	endwin();
986	<	exit(0);
984	>	/* Quit */
985	>	case 'Q':
986	>	case 'q':
987	>	endwin();
988	>	exit(0);
989	>	break;
990	>
991	>	/* Sort by */
992	>	case 'C':
993	>	sortby_ptr=cmp_cpu_used;
994	>	strlcpy(display_config.sortby, CPU_USED, SORTBYMAXNAME);
995	>	break;
996	>
997	>	case 'M':
998	>	sortby_ptr=cmp_memory_used_pecent;
999	>	strlcpy(display_config.sortby, MEM, SORTBYMAXNAME);
1000	>	break;
1001	>
1002	>	case 'L':
1003	>	sortby_ptr=cmp_load_1;
1004	>	strlcpy(display_config.sortby, LOAD, SORTBYMAXNAME);
1005	>	break;
1006	>
1007	>	case 'S':
1008	>	sortby_ptr=cmp_swap_used_pecent;
1009	>	strlcpy(display_config.sortby, SWAP, SORTBYMAXNAME);
1010	>	break;
1011	>
1012	>	case 'N':
1013	>	if(sortby_ptr==cmp_network_io_total){
1014	>	strlcpy(display_config.sortby, NETIORX, SORTBYMAXNAME);
1015	>	sortby_ptr=cmp_network_io_total_rx;
1016	>	}else if(sortby_ptr==cmp_network_io_total_rx){
1017	>	strlcpy(display_config.sortby, NETIOTX, SORTBYMAXNAME);
1018	>	sortby_ptr=cmp_network_io_total_tx;
1019	>	}else{
1020	>	strlcpy(display_config.sortby, NETIO, SORTBYMAXNAME);
1021	>	sortby_ptr=cmp_network_io_total;
1022	>	}
1023	>	break;
1024	>	case 'D':
1025	>	if(sortby_ptr==cmp_disk_io_total){
1026	>	strlcpy(display_config.sortby, DISKIOR, SORTBYMAXNAME);
1027	>	sortby_ptr=cmp_disk_io_total_read;
1028	>	}else if(sortby_ptr==cmp_disk_io_total_read){
1029	>	strlcpy(display_config.sortby, DISKIOW, SORTBYMAXNAME);
1030	>	sortby_ptr=cmp_disk_io_total_write;
1031	>	}else{
1032	>	strlcpy(display_config.sortby, DISKIO, SORTBYMAXNAME);
1033	>	sortby_ptr=cmp_disk_io_total;
1034	>	}
1035	>	break;
1036	>
1037	>	/* Display */
1038	>
1039	>	case 'd':
1040	>	if(display_config.disk_io_total_read){
1041	>	display_config.disk_io_total_read=0;
1042	>	display_config.disk_io_total_write=0;
1043	>	}else{
1044	>	display_config.disk_io_total_read=1;
1045	>	display_config.disk_io_total_write=1;
1046	>	}
1047	>	break;
1048	>	case 'n':
1049	>	if(display_config.network_io_total_rx){
1050	>	display_config.network_io_total_rx=0;
1051	>	display_config.network_io_total_tx=0;
1052	>	}else{
1053	>	display_config.network_io_total_rx=1;
1054	>	display_config.network_io_total_tx=1;
1055	>	}
1056	>	break;
1057	>	case 'm':
1058	>	if(display_config.memory_used_pecent){
1059	>	display_config.memory_used_pecent=0;
1060	>	}else{
1061	>	display_config.memory_used_pecent=1;
1062	>	}
1063	>	break;
1064	>
1065	>	case 's':
1066	>	if(display_config.swap_used_pecent){
1067	>	display_config.swap_used_pecent=0;
1068	>	}else{
1069	>	display_config.swap_used_pecent=1;
1070	>	}
1071	>	break;
1072	>	case 'l':
1073	>	if(display_config.load_1){
1074	>	display_config.load_1=0;
1075	>	}else{
1076	>	display_config.load_1=1;
1077	>	}
1078	>	break;
1079	>	case 'p':
1080	>	if(display_config.pages_in){
1081	>	display_config.pages_in=0;
1082	>	display_config.pages_out=0;
1083	>	}else{
1084	>	display_config.pages_in=1;
1085	>	display_config.pages_out=1;
1086	>	}
1087	>	break;
1088	>	case 'c':
1089	>	if(display_config.cpu_used){
1090	>	display_config.cpu_used=0;
1091	>	}else{
1092	>	display_config.cpu_used=1;
1093	>	}
1094	>	break;
1095	>
1096	>	default:
1097	>	/* Invalid key.. Ignore.. Set Title to -1, as the
1098	>	* title++ will then make that "0" (false) so a
1099	>	* screen redraw will not happen */
1100	>	title=-1;
1101	>	break;
1102		}
1103	+
1104	+	/* Increment title so it becomes true (and making the screen update */
1105	+	title++;
1106	+
1107		}
1108		if(FD_ISSET(data_fileno, &infds)){
1109		response=fpgetline(data);
#	Line 883 | Line 1118 | int main(int argc, char **argv){
1118		if(num_hosts==-1) continue;
1119		machine_data_list=sort_machine_stats(machine_data_list, num_hosts, sortby_ptr);
1120		if(max_display==0){
1121	<	display(machine_data_list, &display_config, num_hosts, &title);
1121	>	display(machine_data_list, &display_config, maxy, &title);
1122		}else{
1123		display(machine_data_list, &display_config, max_display, &title);
1124		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines