timeserver.c

linux下编写的一个时间定时触发器

using namespace std;
#include<iostream>
#include<string>
#include <bitset>

#include <stdio.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/msg.h>
#include <unistd.h>
#include <pthread.h>

#include <hash_map.h>

#include "sesMsgQueue.H"
#include "sesSelTimeOut.H"

#define key_mq_timeserver 	20
#define key_mq_scantask 	30

#define MASK_MAXSIZE        16           

sesMsgQueue *msgque;

struct sTimeEvent
{
	char srcNameId[20];
	unsigned long time_startup;
	unsigned long time_interval;
	int imask;
};
struct sTimeEvent timeevent;

typedef hash_multimap<long, sTimeEvent> map_type;
typedef map_type::iterator MapIter;
map_type hm_timeevent;

sesSelTimeOut delaytimeout;
SelTime_T g_zeroTime;

int msqid_timeserver, msqid_scantask;
struct msqid_ds msg_timeserverinfo;

struct MyTime
{
	int year;
	int mon;
	int day;
	int hour;
	int min;
	int sec;
};

void ArbitraryToAlg(char *num_arb,int *num_alg,int n)
{
    char *pArb=num_arb;
    int temp,var;
    
    /* 移到最后一个不为'\0'的位置 */
    for (;*(pArb+1);pArb++);    

    for (*num_alg=0,var=1;*pArb;pArb--,var*=n) 
	{
        temp=(*pArb>='A')?*pArb-'A'+10:*pArb-'0';
        *num_alg+=temp*var;
    }
}

int GetMonthDays(int year, int month)
{
	int days;
	if(month==1 || month==3 || month==5 || month==7 || month==8 || month==10 || month==12)
		days = 31;
	if(month==4 || month==6 || month==9 || month==11)
		days = 30;
	if(month==2)
	{
		if((year%4==0 && year%100!=0) || year%400==0)
			days = 29;
		else 
			days = 28;
	}
	return days;
}

struct tm *GetStartTime(MyTime mystarttime)
{
	time_t t, stime;
	t=time(NULL);
	struct tm *ltm, *tmptime;
	ltm=localtime(&t);
	tmptime = ltm;
	MyTime localtime;
	localtime.year=ltm->tm_year;
	localtime.mon=ltm->tm_mon;
	localtime.day=ltm->tm_mday;
	localtime.hour=ltm->tm_hour;
	localtime.min=ltm->tm_min;
	localtime.sec=ltm->tm_sec;
/*
	printf("now   time: %d,%d,%d,%d:%d:%d\n", 1900+localtime.year, 1+localtime.mon, localtime.day,
													localtime.hour, localtime.min, localtime.sec);
	printf("time  flag: %d,%d,%d,%d,%d,%d\n", mystarttime.year, mystarttime.mon, mystarttime.day,
													mystarttime.hour, mystarttime.min, mystarttime.sec);
*/	
	//get start time
	if(mystarttime.year==-1 && mystarttime.mon==-1 && mystarttime.day==-1 && 
	mystarttime.hour==-1 && mystarttime.min==-1 && mystarttime.sec==-1)
		return tmptime;
	else
	{
		//sec
		if(mystarttime.sec > -1)
			tmptime->tm_sec = mystarttime.sec;
		else if(mystarttime.sec < -1)
		{
			while(tmptime->tm_sec % mystarttime.sec != 0)
			{
				if(tmptime->tm_sec < 59)
					tmptime->tm_sec++;
				else
					tmptime->tm_sec = 0;
			}
		}
		//min
		if(mystarttime.min > -1)
			tmptime->tm_min = mystarttime.min;
		else if(mystarttime.min < -1)
		{
			while(tmptime->tm_min % mystarttime.min != 0)
			{
				if(tmptime->tm_min < 59)
					tmptime->tm_min++;
				else
					tmptime->tm_min = 0;
			}	
		}
		//hour
		if(mystarttime.hour > -1)
			tmptime->tm_hour = mystarttime.hour;
		else if(mystarttime.hour < -1)
		{
			while(tmptime->tm_hour % mystarttime.hour != 0)
			{
				if(tmptime->tm_hour < 23)
					tmptime->tm_hour++;
				else
					tmptime->tm_hour = 0;							
			}
		}
		//mon	
		if(mystarttime.mon > 0)
			tmptime->tm_mon = mystarttime.mon-1;
		else if(mystarttime.mon < -1)
		{
			while(tmptime->tm_mon % mystarttime.mon != 0)
			{
				if(tmptime->tm_mon <12)
					tmptime->tm_mon++;
				else
					tmptime->tm_mon = 0;
			}								
		}
		//year	
		if(mystarttime.year > -1)
			tmptime->tm_year=mystarttime.year;
		else if(mystarttime.year < -1)
		{
			while(tmptime->tm_year % mystarttime.year != 0)
				tmptime->tm_year++;
		}
		//day	
		if(mystarttime.day > -1)
			tmptime->tm_mday = mystarttime.day;
		else if(mystarttime.day < -1)
		{
			int days = GetMonthDays(tmptime->tm_year, tmptime->tm_mon+1);
			while(tmptime->tm_mday % mystarttime.day != 0)
			{
				if(tmptime->tm_mday <days)
					tmptime->tm_mday++;
				else
					tmptime->tm_mday=0;
			}								
		}

		stime = mktime(tmptime);

		if(stime < t)
		{
			if(tmptime->tm_mon<localtime.mon && mystarttime.year==-1)
			{
				tmptime->tm_year++;
				return tmptime;
			}
			if(tmptime->tm_mday<localtime.day)
			{
				if(mystarttime.mon==-1)
					tmptime->tm_mon++;
				else
					if(mystarttime.year==-1)
						tmptime->tm_year++;
				return tmptime;
			}
			if(tmptime->tm_hour<localtime.hour)
			{
				int days = GetMonthDays(tmptime->tm_year, tmptime->tm_mon+1);
				//printf("tmptime->tm_mday+1=%d, days=%d\n", tmptime->tm_mday+1, days);
				if(mystarttime.day==-1 && (tmptime->tm_mday+1)<=days)
					tmptime->tm_mday++;
				else
				{
					if(mystarttime.mon==-1)
						tmptime->tm_mon++;
					else
						if(mystarttime.year==-1)
							tmptime->tm_year++;
				}
				return tmptime;
			}
			if(tmptime->tm_min<localtime.min)
			{
				if(mystarttime.hour==-1)
					tmptime->tm_hour++;
				else
				{
					if(mystarttime.day==-1)
						tmptime->tm_mday++;
					else
					{
						if(mystarttime.mon==-1)
							tmptime->tm_mon++;
						else
							if(mystarttime.year==-1)
								tmptime->tm_year++;
					}
				}
				return tmptime;
			}
			if(tmptime->tm_sec<localtime.sec && mystarttime.min==-1)
			{
				//tmptime->tm_min++;
				if(mystarttime.min==-1)
					tmptime->tm_min++;
				else
				{
					if(mystarttime.hour==-1)
						tmptime->tm_hour++;
					else
					{
						if(mystarttime.day==-1)
							tmptime->tm_mday++;
						else
						{
							if(mystarttime.mon==-1)
								tmptime->tm_mon++;
							else
								if(mystarttime.year==-1)
									tmptime->tm_year++;
						}
					}
				}
				return tmptime;
			}
		}
		return tmptime;
	}
}

int Select(SelTime_T *t)
{
	int ret = select(1, NULL, NULL, NULL, t);
	if (0 > ret)
	{
		printf("can't select().\n");
		fflush(stdout);
	}
	else if (0 == ret)  
	{
		//timeout
		printf("time out.\n");
	}
	return ret;
}

void hm_timeevent_ShowInfo()
{
	MapIter mapiter;
	for(mapiter = hm_timeevent.begin();
		mapiter != hm_timeevent.end();
		mapiter++)
	{
		printf("mapiter->second.time_startup=%ld\n", mapiter->second.time_startup);
		printf("mapiter->second.time_interval=%ld\n", mapiter->second.time_interval);
		//printf("mapiter->second.imask=%d\n", mapiter->second.imask);		
	}
}

void TimeOut_CallBack(const map_type& Map, long ltime)
{
//	cout <<endl << ltime << ": " <<endl;
	pair<map_type::const_iterator, map_type::const_iterator> p =
		Map.equal_range(ltime);
	//printf("equal_range(%ld)\n", ltime);
	for (map_type::const_iterator i = p.first; i != p.second; ++i)
	{
//		cout << "timeevent.srcNameId = " << (*i).second.srcNameId << " " << endl;

		//send mask to scantask     
		struct sesMsg sndmsg;
		sndmsg.msghead.type=1;
		sndmsg.msghead.srcPid=key_mq_timeserver;
		sndmsg.msghead.destPid=key_mq_scantask;
		sndmsg.msghead.responseFlag=0;
		sndmsg.message=(char*)malloc(MASK_MAXSIZE);
		sprintf(sndmsg.message, "%ld", (*i).second.imask);		
		//printf("sndmsg.message=%s\n", sndmsg.message);
		sndmsg.msghead.msgSize=strlen(sndmsg.message);

		printf("TimeServer--->send a meassage to scantask...\n");		
		msgque->MsqSendTo(msqid_scantask, sndmsg);

				SelTime_T starttime;
				starttime.tv_sec = timeevent.time_startup;	
				starttime.tv_usec = 0;					
		//delaytimeout.DelTimeOut((char*)(*i).second.srcNameId);
/*		if((*i).second.time_interval > 0)
		{
			SelTime_T t;
			t.tv_sec = ltime+(*i).second.time_interval;
			t.tv_usec = 0;
			delaytimeout.RaiseTimeOut(t, (*i).second.time_interval, (char*)(*i).second.srcNameId);
			printf("RaiseTimeOut(%ld,%ld)\n",t.tv_sec, (*i).second.time_interval);	
		}*/ 
	}
//	cout << endl;
}

void IsOrNotLoop(map_type& Map, long ltime)
{	
	int searchover=1;
	while(searchover)
	{
		searchover=0;
		pair<map_type::iterator, map_type::iterator> p = Map.equal_range(ltime);

		for(map_type::iterator i=p.first; i!=p.second; i++)
		{
			printf("(*i).second.time_startup=%ld\n", (*i).second.time_startup);
			printf("(*i).second.time_interval=%ld\n", (*i).second.time_interval);
			if(((*i).second.time_interval) > 0)
			{
				strcpy(timeevent.srcNameId, (*i).second.srcNameId);
				timeevent.time_startup=(*i).second.time_startup+(*i).second.time_interval;
				timeevent.time_interval=(*i).second.time_interval;
				printf("*** hm_timeevent.erase(%ld, %ld)\n", (*i).second.time_startup, (*i).second.time_interval);
				hm_timeevent.erase(i);
				hm_timeevent.insert(map_type::value_type(timeevent.time_startup, timeevent));				
				printf("hm_timeevent.insert(map_type::value_type(%ld)\n", timeevent.time_startup);
				
				SelTime_T starttime;
				starttime.tv_sec = timeevent.time_startup;	
				starttime.tv_usec = 0;					
				
				printf("  [loop per %d sec]\n", (*i).second.time_interval);
				delaytimeout.RaiseTimeOut(starttime, timeevent.time_interval, timeevent.srcNameId);	
				printf("RaiseTimeOut(%ld,%ld)\n",starttime.tv_sec, timeevent.time_interval);	
				//searchover=1;
				break;
			}
			else
			{
				printf("  [no loop]\n");
				printf("*** hm_timeevent.erase(%ld, %ld)\n", (*i).second.time_startup, (*i).second.time_interval);
				hm_timeevent.erase(i);
				//searchover=1;
				break;
			}
		}
	}
	hm_timeevent_ShowInfo();
	//printf("hm_timeevent.size()=%d\n", hm_timeevent.size());
	delaytimeout.ShowInfo();
}

void* ScanMsgQue(void* data)
{
	while(1)
	{
		int qcnum = msgque->GetMsgCount(msqid_timeserver);
		struct sesMsg rcvmsg;
		if(qcnum>0)
		{
			printf("have %d message\n",qcnum);
			rcvmsg.message=(char*)malloc(SESMSG_MAX_SIZE);
			msgque->MsqRecv(msqid_timeserver, &rcvmsg);

			if(rcvmsg.msghead.type==1) //msg type = time
			{
				char msgsmask[MASK_MAXSIZE];
				int imask;
				memcpy(msgsmask, rcvmsg.message, rcvmsg.msghead.msgSize);
				imask = atoi(msgsmask);
				//printf("imask=%d\n", imask);

				string s = bitset<MASK_MAXSIZE>(imask).template to_string<char, char_traits<char>, allocator<char> >();
				strcpy(msgsmask, s.c_str());
				
				//printf("msgsmask=%s\n", msgsmask);

				for(int i=0;i<MASK_MAXSIZE;i++)
				{
					//get time map index by API;
					if(msgsmask[i]=='1')
					{
						MyTime mystarttime, myrepeattime;
						time_t stime, rtime;
						struct tm *st;

						//get start time
						mystarttime.year=-1; mystarttime.mon=-1;  mystarttime.day=-1;
						mystarttime.hour=-1; mystarttime.min=-1; mystarttime.sec=10+i*3;
						//printf("mystarttime.sec=10+%d*5=%d\n",i,10+i*5);
						st = GetStartTime(mystarttime);
						//printf("start time: %d,%d,%d,%d:%d:%d\n", 1900+st->tm_year, 1+st->tm_mon, st->tm_mday,
						//												st->tm_hour, st->tm_min, st->tm_sec);

						stime = mktime(st);

						//get repeat time
						myrepeattime.year=0; myrepeattime.mon=0;  myrepeattime.day=0;
						myrepeattime.hour=0;  myrepeattime.min=0; 
						if(i==0)
							myrepeattime.sec=5;
						else if(i==1)
							myrepeattime.sec=3;
						else
							myrepeattime.sec=0;

						rtime=(((myrepeattime.day*24+myrepeattime.hour)*60+myrepeattime.min)*60)+myrepeattime.sec;

						SelTime_T starttime, repeattime;
						starttime.tv_sec = (long)stime;	
						starttime.tv_usec = 0;					
						repeattime.tv_sec = (long)rtime;	
						repeattime.tv_usec = 0;					
						timeevent.time_startup=starttime.tv_sec;
						timeevent.time_interval=repeattime.tv_sec;
						char event_smask[MASK_MAXSIZE+1];
						memset(event_smask, 0, MASK_MAXSIZE+1);
						memset(event_smask, '0', MASK_MAXSIZE);
						event_smask[i]='1';
						//printf("event_smask=%s\n", event_smask);

						int event_imask;
						ArbitraryToAlg(event_smask, &event_imask, 2); 

						timeevent.imask=event_imask;
						//printf("timeevent.imask=%d\n", timeevent.imask);	

						hm_timeevent.insert(map_type::value_type(timeevent.time_startup, timeevent));
						printf("hm_timeevent.insert(map_type::value_type(%ld)\n", timeevent.time_startup);
						delaytimeout.RaiseTimeOut(starttime, timeevent.time_interval, timeevent.srcNameId);	
						printf("RaiseTimeOut(%ld,%ld)\n",starttime.tv_sec, timeevent.time_interval);	
					}
				}
				hm_timeevent_ShowInfo();
			}
			free(rcvmsg.message);
		}
	}
	pthread_exit(NULL);
}

void* selecttimeout(void*)
{
	int curfd;
	SelTime_T cur,ft,st,s1;
	s1.tv_sec=1;
	s1.tv_usec=0;

	while(1)
	{
		ft = delaytimeout.GetFirstTimeOut();
		if (ft == g_zeroTime)
		{
		  	//printf("In while circle ,before select\n");
		  	//curfd = Select(NULL);
		}
		else
		{
			gettimeofday(&cur, NULL);
			st=ft;
			st = st - cur;
			st = st + s1;
			if(st.tv_sec>0)
			{
				printf("=====================================================\n");
				printf("cur.tv_sec = %ld, then Select(%ld)\n", cur.tv_sec, st.tv_sec);
			
				curfd = Select(&st);
				if (0 == curfd)					//is timeout
				{
					gettimeofday(&cur, NULL);
					if(cur>ft |cur==ft){
					//printf("cur.tv_sec = %ld\n", cur.tv_sec);
					//printf("ft.tv_sec = %ld\n", ft.tv_sec);

					//////////////////////////////////////////////////////////
					//printf("in there, i will add time out function!!!\n");
					//////////////////////////////////////////////////////////

					printf("TimeOut_CallBack(hm_timeevent, %d)\n", ft.tv_sec);
					TimeOut_CallBack(hm_timeevent, ft.tv_sec);

					printf("IsOrNotLoop(hm_timeevent, %d)\n", ft.tv_sec);
					IsOrNotLoop(hm_timeevent, ft.tv_sec);
					}
					continue;
				}
			}
		}
	}
	//pthread_exit(NULL);
}

int main()
{
	msgque = new sesMsgQueue();
	msqid_timeserver = msgque->MsqCreate(key_mq_timeserver);
	msgque = new sesMsgQueue();
	msqid_scantask = msgque->MsqCreate(key_mq_scantask);

	int rc;
	pthread_t thread_selecttimeout;
	rc=pthread_create(&thread_selecttimeout, NULL, selecttimeout, NULL);
	if(rc!=0)
	{
		printf ("Create pthread error!\n");
		exit (1);
	}

	pthread_t thread_scanmsgque;
	rc=pthread_create(&thread_scanmsgque, NULL, ScanMsgQue, NULL);
	if(rc!=0)
	{
		printf ("Create pthread error!\n");
		exit (1);
	}

	while(1);
	exit(0);
}