send_message_toserver.cxx

HPunix下资源监视程序,查看监视进程的CPU、内存的参数

		sleep(moni_interval);
	}
}
void send_allmsg_tosvr(int svr1,int svr2,int *svr1_flag,int *svr2_flag,char *buf_svr)
{
	#ifdef TEST
	printf("now send all message to server **************\n");
	#endif
	int tbnum,len,j;
	char  svr_open_flag=0;
	for (tbnum=1;tbnum<5;tbnum++)
	{
		len=fill_message_toserver(buf_svr,tbnum);
		if(len<0)
		{
			#ifdef TEST
			printf("fill_message_toserver len=%d\n",len);
			#endif
			continue;
		}	

		if(*svr1_flag==1)
			j=ptop_write_message(svr1,buf_svr,len);
		if(j<=0)
		{
			#ifdef TEST
			printf("wk_station write to svr1  return value is %d \n",j);
			#endif
			if((j==-2)||(j==-1))
			{
				*svr1_flag=-1;
				close(svr1);
			}
		}

		if(*svr2_flag==1)
			j=ptop_write_message(svr2,buf_svr,len);
		if(j<=0)
		{
			#ifdef TEST
			printf("wk_station write to svr2  return value is %d \n",j);
			#endif
			if((j==-2)||(j==-1))
			{
				*svr2_flag=-1;
				close(svr2);
			}
		}
	}    
}

int	fill_message_toserver(char *ptr,int mestype)
{
	//printf("now fill_message_toserver running**********\n");
	char	temp[1024],buffer[1024];
	int	num=0;
	int     ret,i;
	struct PARTITIONMESSAGE	*partitioninfo_ptr;
	struct SYSMESSAGE	*sysinfo_ptr;
	//struct NETMESSAGE	*net_message_ptr;

	bzero(temp,1024);

	if(mestype==1)
	{
	
		int total_size;
		float used_size;
		char tempchar[10];
		FILE *fp;
		//printf("mestype is %d************\n",mestype);
		PARTITIONMESSAGE partitioninfo_temp;
		partitioninfo_ptr=&partitioninfo_temp;
		strcpy(partitioninfo_ptr->Node_name,hostname);
		for(i=0;i<part_num;i++)
		{
			getpartinfo((part_name_ptr+i)->name,&total_size,&used_size);
			(partition_message_ptr+i)->Part_size=total_size;
			(partition_message_ptr+i)->Part_used=used_size;
			//printf("%s__%d__%f\n",(partition_message_ptr+i)->Id,(partition_message_ptr+i)->Part_size,(partition_message_ptr+i)->Part_used);
		}

		buffer[0]=0xeb;
		buffer[1]=(sizeof(struct PARTITIONMESSAGE)*part_num+3)%256;
		buffer[2]=(sizeof(struct PARTITIONMESSAGE)*part_num+3)/256;
		buffer[3]=mestype;//prototype
		buffer[4]=part_num;//block num
		memcpy(&buffer[5],partition_message_ptr,sizeof(struct PARTITIONMESSAGE)*part_num);
		buffer[sizeof(struct PARTITIONMESSAGE)*part_num+5]=0x16;
		num=sizeof(struct PARTITIONMESSAGE)*part_num+6;
		memcpy(ptr,buffer,num);

	}
	else if(mestype==2)
	{       
	
		int ret;
		int mem_size;
		float mem_used=0;
		float cpu_used;
		//printf("mestype is %d************\n",mestype);
		sysinfo_ptr=(struct SYSMESSAGE *)temp;
		strcpy(sysinfo_ptr->Node_name,hostname);
		if(getcpuinfo (&cpu_used)==0)
		{
			sysinfo_ptr->Cpu_used=cpu_used;
		}
		else
		{
			sysinfo_ptr->Cpu_used=-1;
			printf("getcpuinfo failed!\n");
		}

		if(getmeminfo(&mem_size,&mem_used)==0)
		{
			sysinfo_ptr->Mem_used=mem_used;
			sysinfo_ptr->Mem_size=mem_size;
		}
		else
		{
			sysinfo_ptr->Mem_used=-1;
			sysinfo_ptr->Mem_size=-1;
			printf("getmeminfo failed!\n");
		}
		#ifdef TEST
		printf("cpu_used is %f,memory_size is %d,memory_used is %f\n",sysinfo_ptr->Cpu_used,sysinfo_ptr->Mem_size,sysinfo_ptr->Mem_used); 
		#endif

		buffer[0]=0xeb;
		buffer[1]=(sizeof(struct SYSMESSAGE)+3)%256;
		buffer[2]=(sizeof(struct SYSMESSAGE)+3)/256;
		buffer[3]=mestype;//prototype
		buffer[4]=1;//block num
		memcpy(&buffer[5],sysinfo_ptr,sizeof(struct SYSMESSAGE));
		buffer[sizeof(struct SYSMESSAGE)+5]=0x16;
		num=sizeof(struct SYSMESSAGE)+6;
		memcpy(ptr,buffer,num);

	}
	else if(mestype==3)
	{
	
		//printf("mestype is %d************\n",mestype);
		if(getnetinfo(net_message_ptr)==0)
		{	
			
			//strcpy(net_message_ptr->Node_name,hostname);
			#ifdef TEST
			net_message_ptr1=net_message_ptr;
			for(int l=0;l<net_num;l++)
			{
				//printf("Net_speed of %s is %d\n",net_message_ptr1->Net_name,net_message_ptr1->Net_speed);
				net_message_ptr1++;
			}
			#endif
		}
		else
		{
			net_message_ptr1=net_message_ptr;
			for(int k=0;k<net_num;k++)
			{
			  (net_message_ptr1+k)->Net_speed=-1;
			  bzero((net_message_ptr1+k)->Net_address,20);
			}
		}

		buffer[0]=0xeb;
		buffer[1]=(net_num*sizeof(struct NETMESSAGE)+3)%256;
		buffer[2]=(net_num*sizeof(struct NETMESSAGE)+3)/256;
		buffer[3]=mestype;//prototype
		buffer[4]=net_num;//block num
		memcpy(&buffer[5],net_message_ptr,net_num*sizeof(struct NETMESSAGE));
		buffer[net_num*sizeof(struct NETMESSAGE)+5]=0x16;
		num=net_num*sizeof(struct NETMESSAGE)+6;
		memcpy(ptr,buffer,num);
		
	}
	else if(mestype==4)
	{
		//printf("mestype is %d************\n",mestype);
		
		float process_cpuload=0;
		proc_name_ptr1=proc_name_ptr;
		pthread_message_ptr1=pthread_message_ptr;
		for(i=0;i<proc_num;i++)
		{
			if(getprocinfo_status==0)
			{
				getpthreadinfo(proc_name_ptr1->name,pthread_message_ptr1);
				#ifdef TEST
				printf("cpuload of process %10s is %4.4f%s!\n",pthread_message_ptr1->Pthread_name,
				pthread_message_ptr1->Pthread_cpuload,"%");
				printf("status is %d,memload is %f\n",pthread_message_ptr1->Pthread_status,pthread_message_ptr1->Pthread_memload);
				#endif
			}
			else
			{

				pthread_message_ptr1->Pthread_cpuload=-1;
				pthread_message_ptr1->Pthread_status=-1;
				pthread_message_ptr1->Pthread_memload=-1;

			}
			pthread_message_ptr1++;
			proc_name_ptr1++;
		}
		buffer[0]=0xeb;
		buffer[1]=(proc_num*sizeof(struct PTHREADMESSAGE)+3)%256;
		buffer[2]=(proc_num*sizeof(struct PTHREADMESSAGE)+3)/256;
		buffer[3]=mestype;//prototype
		buffer[4]=proc_num;//block num
		memcpy(&buffer[5],pthread_message_ptr,sizeof(struct PTHREADMESSAGE)*proc_num);
		buffer[buffer[4]*sizeof(struct PTHREADMESSAGE)+5]=0x16;
		num=buffer[4]*sizeof(struct PTHREADMESSAGE)+6;
		memcpy(ptr,buffer,num);
	}
	 	//printf("now fill_message_toserver over*****************\n");	
		return(num);
}
int getpartinfo(const char *dri_name,int *total_s,float *use_s)
{
	//printf("now getpartinfo is running\n");
	struct statfs statfsfile;
	int retgetpartinfo;
	int dri_size,free_size,avail_size,used_size;
	long block_size;
	bzero(&statfsfile,sizeof(struct statfs));
	retgetpartinfo=statfs(dri_name,&statfsfile);
	if (retgetpartinfo==0)
	{
                *total_s=statfsfile.f_bsize/1024*statfsfile.f_blocks/1024;
	        int use= statfsfile.f_bsize/1024*(statfsfile.f_blocks-statfsfile.f_bfree)/1024;
	        *use_s=(100*(float)use)/((float)*total_s);
		return 0;

	}
	else
	{
		printf("get partition %s failed!\n",dri_name);
		*total_s=-1;
		*use_s=-1;
		return -1;
	}
}
int getcpuinfo (float *cpu_used)
{
 	if(pstat_getprocessor(psp, sizeof(struct pst_processor), nspu, 0)  != -1)
	{
		 int i;
		 float cpu_iddle=0;
		 _T_ULONG_T temp_iddle,temp_user,temp_sys;
		 for (i = 0; i < nspu; i++)
		 {
			  temp_iddle=labs(psp[i].psp_idlecycles.psc_lo-psp_last[i].psp_idlecycles.psc_lo);
			  temp_user=labs(psp[i].psp_usercycles.psc_lo-psp_last[i].psp_usercycles.psc_lo);
			  temp_sys=labs(psp[i].psp_systemcycles.psc_lo-psp_last[i].psp_systemcycles.psc_lo); 
			  cpu_iddle+=(float)temp_iddle/(float)(temp_iddle+temp_user+temp_sys);
			  psp_last[i].psp_idlecycles.psc_lo=psp[i].psp_idlecycles.psc_lo;
			  psp_last[i].psp_usercycles.psc_lo=psp[i].psp_usercycles.psc_lo;
			  psp_last[i].psp_systemcycles.psc_lo=psp[i].psp_systemcycles.psc_lo;
		}
		#ifdef TEST
		printf("cpu iddle is %4.2f\n",cpu_iddle*100/nspu);
		#endif
		*cpu_used=100-cpu_iddle/nspu*100;
		return 0;
	 }
	 else
	 {
	 	perror("pstat_getdynamic");
		return -1;
	 }
}
int getmeminfo (int *Mem_size,float *Mem_used)
{
	int ret,temp_int;
	FILE *fp;
	char temp_str[15];
	fp=popen("swapinfo -tam|grep memory","r");
	if(fp==NULL)
	{
		perror("popen swapinfo failed!\n");
		pclose(fp);
		exit(-1);
		return(-1);
	}

	fscanf(fp,"%s",temp_str);
	if(fscanf(fp,"%d",&temp_int)!=EOF)
	{
		*Mem_size=temp_int;	
	}
	else
	{
		*Mem_size=-1;
		*Mem_used=-1;
		printf("Get memory info failed!\n");
		pclose(fp);
		return -1;
	}
  if(fscanf(fp,"%d",&temp_int)!=EOF)
	{
		*Mem_used=100*(float)temp_int/(float)(*Mem_size);     
	}
	else
	{
		*Mem_used=-1;
		printf("Get memory info failed!\n");
		pclose(fp);
		return -1;
	}
	ret=pclose(fp);
	if(ret==-1)
	{
		perror("pclose failed");
		return -1;
	}
	return 0;
}

int getnetinfo(struct NETMESSAGE * net_message_ptr)
{
		
	//printf("getnetinfo starting\n");
	FILE *fpr;
	int package_size=0;
	char temp_str[40];
	int i,ret;
	fpr=popen("netstat -ni|grep -v Name|grep -v lo0","r");
	if(fpr==NULL)
	{
		perror("popen netstat failed!\n");
		pclose(fpr);
		exit(-1);
		return(-1);
	}
 	while(fscanf(fpr,"%s",temp_str)!=EOF)
	{
		if((strstr(temp_str,"lan")!=NULL)&&(strlen(temp_str)==4))
		{
			
			net_name_ptr1=net_name_ptr;
			for(int k=0;k<net_num;k++)
			{
				
				if(!strcmp(temp_str,(net_name_ptr1+k)->name))
				{
					fscanf(fpr,"%d",&package_size);
					//printf("package_size is %d\n",package_size);
					fscanf(fpr,"%s",temp_str);
					fscanf(fpr,"%s",(net_message_ptr+k)->Net_address);	
					fscanf(fpr,"%ld",&((cur_net_ptr+k)->netRx));	
					fscanf(fpr,"%s",temp_str);
					fscanf(fpr,"%ld",&((cur_net_ptr+k)->netTx));	
					(net_message_ptr+k)->Net_speed=package_size*((cur_net_ptr+k)->netRx-(prev_net_ptr+k)->netRx+
																								(cur_net_ptr+k)->netTx-(prev_net_ptr+k)->netTx)/(moni_interval*1000);
				  //printf("curRx is %d,curTx is %d,preRx is %d,preTx is %d\n",(cur_net_ptr+k)->netRx,(cur_net_ptr+k)->netTx,(prev_net_ptr+k)->netRx,(prev_net_ptr+k)->netTx);
					(prev_net_ptr+k)->netRx=(cur_net_ptr+k)->netRx;
					(prev_net_ptr+k)->netTx=(cur_net_ptr+k)->netTx;
					//printf("test:%s---%s---%s\n",(net_message_ptr+k)->Net_address,(net_message_ptr+k)->Net_name,(net_message_ptr+k)->Node_name);
					//printf("test:speed is %d\n",(net_message_ptr+k)->Net_speed);
					//break;
				}
			}
		}
		else if(strstr(temp_str,"IPv6")!=NULL)
		{
			break;	
		}
	}
	ret=pclose(fpr);
	if(ret==-1)
  {
    	printf("pclose error!\n");
      exit(-1);
  }
	return 0;

}
int getpthreadinfo(char * procname,PTHREADMESSAGE * pthreadmes)
{
 	struct pst_status pst[10];
	time_t temp_time;
	int proc_num1=0;
	int i, count;
	int idx = 0; /* index within the context */
	/* loop until count == 0 */
	while ((count = pstat_getproc(pst,sizeof(pst[0]),10,idx)) > 0)
	{
	/* got count (max of BURST) this time. Process them */
		for (i = 0; i < count; i++)
		{
			if(strcmp(pst[i].pst_ucomm,procname)==0)
			{
				 proc_num1++;
				 pthreadmes->Pthread_status=proc_num1;
				 pthreadmes->Pthread_cpuload=pst[i].pst_pctcpu*100;                  
				 pthreadmes->Pthread_memload=4*(pst[i].pst_dsize+pst[i].pst_tsize+pst[i].pst_ssize+pst[i].pst_rssize);

			}
		} 
		idx = pst[count-1].pst_idx + 1;
	 }
	 if(count==-1)
	 {
		pthreadmes->Pthread_status=-1;
		pthreadmes->Pthread_cpuload=-1;
		pthreadmes->Pthread_memload=-1;
	 	perror("pstat_getproc()");
		return -1;
	 }
	 else if(proc_num1==0)
	 {
		pthreadmes->Pthread_status=0;
		pthreadmes->Pthread_cpuload=-1;
		pthreadmes->Pthread_memload=-1;
	 }
	 FILE *fp;
	 char command_line[40];
	 bzero(command_line,40);
	 strcpy(command_line,"UNIX95= ps -e -o vsz,args|grep -v grep|grep -v vi|grep ");
	 strcat(command_line,procname);
	 fp=popen(command_line,"r");
	 if(fp==NULL)
   {
		perror("popen swapinfo failed!\n");
		pclose(fp);
		exit(-1);
		return(-1);
	 }
	 if(fscanf(fp,"%d",&i)!=EOF)
	 	pthreadmes->Pthread_memload=i;
	 pclose(fp);
	 return 0;

}