query.h

件主要用于帮助计算机爱好者学习蚁群算法时做有关蚁群算法的试验。蚁群算法作为一种优秀的新兴的算法

	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryPing(in_remote, in_process));	
	}
		
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbePing(in_src_node, in_remote, in_process));		
	}

	virtual int getLatency(const NodeIdent& inNode, uint32_t* latencyUS);
	
	virtual char getQueryType() {
		return REQ_CONSTRAINT_N_PING;
	}
	
public:				
	HandleMCPing(uint64_t id, u_short in_betaNumer, u_short in_betaDenom,
		const NodeIdentRendv& in_srcNode, 
		const vector<NodeIdentConst>& in_remote, MeridianProcess* in_process) 
			:	HandleMCGeneric(id, in_betaNumer, in_betaDenom, in_srcNode, 
				in_remote, in_process) {}
				
	virtual ~HandleMCPing() {}
};

class HandleMCDNS : public HandleMCGeneric {
protected:
	virtual ReqConstraintGeneric* createReqConstraint(uint64_t id, 
			u_short in_beta_num, u_short in_beta_den, u_int in_rendv_addr, 
			u_short in_rendv_port)  {
		return (new ReqConstraintDNS(id, in_beta_num, 
			in_beta_den, in_rendv_addr, in_rendv_port));			
	}
		
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryDNS(in_remote, in_process));	
	}
		
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeDNS(in_src_node, in_remote, in_process));		
	}

	virtual int getLatency(const NodeIdent& inNode, uint32_t* latencyUS);
	
	virtual char getQueryType() {
		return REQ_CONSTRAINT_N_DNS;
	}
	
public:				
	HandleMCDNS(uint64_t id, u_short in_betaNumer, u_short in_betaDenom,
		const NodeIdentRendv& in_srcNode, 
		const vector<NodeIdentConst>& in_remote, MeridianProcess* in_process) 
			:	HandleMCGeneric(id, in_betaNumer, in_betaDenom, in_srcNode, 
				in_remote, in_process) {}
				
	virtual ~HandleMCDNS() {}
};

#ifdef PLANET_LAB_SUPPORT
class HandleMCICMP : public HandleMCGeneric {
protected:
	virtual ReqConstraintGeneric* createReqConstraint(uint64_t id, 
			u_short in_beta_num, u_short in_beta_den, u_int in_rendv_addr, 
			u_short in_rendv_port)  {
		return (new ReqConstraintICMP(id, in_beta_num, 
			in_beta_den, in_rendv_addr, in_rendv_port));			
	}
		
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryICMP(in_remote, in_process));	
	}
		
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeICMP(in_src_node, in_remote, in_process));		
	}

	virtual int getLatency(const NodeIdent& inNode, uint32_t* latencyUS);
	
	virtual char getQueryType() {
		return REQ_CONSTRAINT_N_ICMP;
	}
	
public:				
	HandleMCICMP(uint64_t id, u_short in_betaNumer, u_short in_betaDenom,
		const NodeIdentRendv& in_srcNode, 
		const vector<NodeIdentConst>& in_remote, MeridianProcess* in_process) 
			:	HandleMCGeneric(id, in_betaNumer, in_betaDenom, in_srcNode, 
				in_remote, in_process) {}
				
	virtual ~HandleMCICMP() {}
};
#endif

#ifdef MERIDIAN_DSL
#include "MQLState.h"
// This query redirects packets to DSLRecvQuery
class DSLReqQuery : public Query {
private:
	uint64_t					qid;	
	bool 						finished;
	struct timeval				timeoutTV;
	MeridianProcess*			meridProcess;
	uint64_t					recvQueryID;
	NodeIdentRendv				destNode;
	uint16_t					ttl;
protected:
	MeridianProcess* getMerid() 					{ return meridProcess; 	}
	void setFinished(bool flag)						{ finished = flag;		}	
	
public:
	DSLReqQuery(MeridianProcess* in_process, const struct timeval& in_timeout,
		uint16_t in_ttl, const NodeIdentRendv& in_dest, uint64_t redirectQID);
		
	virtual ~DSLReqQuery() {}			
	virtual uint64_t getQueryID() const				{ return qid;		}
	virtual struct timeval timeOut() const			{ return timeoutTV;	} 	
	virtual int handleEvent(
		const NodeIdent& in_remote, 
		const char* inPacket, int packetSize); 
	virtual int handleLatency(
		const vector<NodeIdentLat>& in_remoteNodes)	{ return 0;			}		
	virtual int handleTimeout()	{ 
		setFinished(true);
		return 0; 
	}
	virtual bool isFinished() const					{ return finished;	}
	virtual int init()								{ return 0;			}
	// Special for this query
	int init(ParserState* ps, const string* func_name, const ASTNode* param); 
};


class DSLRecvQuery : public Query {
private:
	uint64_t					qid;
	uint64_t					ret_qid;	
	bool 						finished;
	struct timeval				timeoutTV;
	MeridianProcess*			meridProcess;
	ParserState*				ps;
	NodeIdentRendv				srcNode;
	uint16_t					ttl;
protected:
	NodeIdentRendv getSrcNode()						{ return srcNode;		}
	MeridianProcess* getMerid() 					{ return meridProcess; 	}
	void setFinished(bool flag)						{ finished = flag;		}	
	
public:
	DSLRecvQuery(ParserState* in_state, MeridianProcess* in_process,
			const NodeIdentRendv& in_src, uint64_t in_ret_qid, 
			uint16_t timeout_ms, uint16_t in_ttl);
	
	virtual ~DSLRecvQuery() {		
		if (ps) delete ps; // Query gains ownership of ParserState
	}	
	virtual uint64_t getQueryID() const				{ return qid;		}
	virtual struct timeval timeOut() const			{ return timeoutTV;	} 	
	virtual int handleEvent(
		const NodeIdent& in_remote, 
		const char* inPacket, int packetSize);		
	virtual int handleLatency(
		const vector<NodeIdentLat>& in_remoteNodes);
	virtual int handleTimeout()	{ 
		setFinished(true);
		return 0; 
	}
	virtual bool isFinished() const					{ return finished;	}
	virtual int init()								{ return 0; 		}
	ParserState* getPS()							{ return ps;		}
	PSState parserState() const	{
		return ps->parser_state();	
	}
	uint16_t getTTL() {
		return ttl;	
	}	
};


class ReqProbeSelfGeneric : public Query {
private:
	uint64_t							qid;
	set<NodeIdent, ltNodeIdent>			remoteNodes;
	map<NodeIdent, u_int, ltNodeIdent>	remoteLatencies;
	bool 								finished;
	struct timeval						timeoutTV;
	MeridianProcess*					meridProcess;
	vector<uint64_t>					subscribers;
protected:
	set<NodeIdent, ltNodeIdent>* getRemoteNodes() 	{ return &remoteNodes; 	}
	MeridianProcess* getMerid() 					{ return meridProcess; 	}
	void setFinished(bool flag)						{ finished = flag;		}
	
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
		MeridianProcess* in_process) = 0;	
	
public:
	ReqProbeSelfGeneric(const set<NodeIdent, ltNodeIdent>& in_remote, 
				MeridianProcess* in_process);
					
	ReqProbeSelfGeneric(const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
				MeridianProcess* in_process);	
					
	virtual ~ReqProbeSelfGeneric() {}	
	virtual uint64_t getQueryID() const				{ return qid;		}
	virtual struct timeval timeOut() const			{ return timeoutTV;	} 	
	virtual int handleEvent(
		const NodeIdent& in_remote, 
		const char* inPacket, int packetSize)		{ return 0;			}
	virtual int handleLatency(
		const vector<NodeIdentLat>& in_remoteNodes);
	virtual int handleTimeout() {
		finished = true;
		return 0;
	}
	virtual bool isFinished() const					{ return finished;	}		
	virtual int init();
	virtual int subscribeLatency(uint64_t in_qid);
	int returnResults();
};

class ReqProbeSelfTCP : public ReqProbeSelfGeneric {
protected:
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryTCP(in_remote, in_process));	
	}
public:
	ReqProbeSelfTCP(const set<NodeIdent, ltNodeIdent>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {} 	
		
	ReqProbeSelfTCP(const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {}		
		
	virtual ~ReqProbeSelfTCP() {}
};


class ReqProbeSelfDNS : public ReqProbeSelfGeneric {
protected:
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryDNS(in_remote, in_process));	
	}
public:
	ReqProbeSelfDNS(const set<NodeIdent, ltNodeIdent>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {}

	ReqProbeSelfDNS(const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {} 
 		
	virtual ~ReqProbeSelfDNS() {}			
};

class ReqProbeSelfPing : public ReqProbeSelfGeneric {
protected:
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryPing(in_remote, in_process));	
	}
public:
	ReqProbeSelfPing(const set<NodeIdent, ltNodeIdent>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {}				
				
	ReqProbeSelfPing(const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
				MeridianProcess* in_process) 				
		: ReqProbeSelfGeneric(in_remote, in_process) {}
 		
	virtual ~ReqProbeSelfPing() {}			
};

#ifdef PLANET_LAB_SUPPORT
class ReqProbeSelfICMP : public ReqProbeSelfGeneric {
protected:
	virtual ProbeQueryGeneric* createProbeQuery(const NodeIdent& in_remote, 
			MeridianProcess* in_process) {
		return (new ProbeQueryICMP(in_remote, in_process));	
	}
public:
	ReqProbeSelfICMP(const set<NodeIdent, ltNodeIdent>& in_remote, 
				MeridianProcess* in_process) 
		: ReqProbeSelfGeneric(in_remote, in_process) {}				
				
	ReqProbeSelfICMP(const set<NodeIdentConst, ltNodeIdentConst>& in_remote, 
				MeridianProcess* in_process) 				
		: ReqProbeSelfGeneric(in_remote, in_process) {}
 		
	virtual ~ReqProbeSelfICMP() {}			
};
#endif

// Destination nodes cannot be behind firewall. If they are, move them
// to the source side
class HandleGetDistanceGeneric : public Query {
private:		
	uint64_t										qid;
	bool 											finished;
	//struct timeval									startTime;
	struct timeval									timeoutTV;
	MeridianProcess*								meridProcess;	
	vector<NodeIdentRendv> 							srcNodes;
	set<int>										receivedRow;	
	//	Need this vector to keep the ordering and rendv 
	vector<NodeIdent>								destNodesVect;	
	set<NodeIdent, ltNodeIdent>						destNodes;
	uint32_t* 										latencyMatrixUS;
	uint64_t										prevQID;	
protected:
	MeridianProcess* getMerid() 					{ return meridProcess; 	}
	void setFinished(bool flag)						{ finished = flag;		}
	
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
		const set<NodeIdent, ltNodeIdent>& in_remote, 
		MeridianProcess* in_process) = 0;
		
	virtual ReqProbeSelfGeneric* createReqSelfProbe(
		const set<NodeIdent, ltNodeIdent>& in_remote, 
		MeridianProcess* in_process) = 0;		
		
public:
	HandleGetDistanceGeneric(const vector<NodeIdentRendv>& in_src,	
				const vector<NodeIdentRendv>& in_remote, 
				MeridianProcess* in_process, 
				u_int in_timeout_ms, uint64_t in_prevQID);
							
	virtual ~HandleGetDistanceGeneric();
	virtual uint64_t getQueryID() const				{ return qid;		}
	virtual struct timeval timeOut() const			{ return timeoutTV;	} 	
	virtual int handleEvent(
		const NodeIdent& in_remote, 
		const char* inPacket, int packetSize)		{ return 0;			}		
	virtual int handleLatency(
			const vector<NodeIdentLat>& in_remoteNodes);
	virtual int handleTimeout() 					{ return returnResults(); }		
	virtual bool isFinished() const					{ return finished;	}	
	virtual int init();
	int returnResults();
};

class HandleGetDistanceTCP : public HandleGetDistanceGeneric {
protected:	
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeTCP(in_src_node, in_remote, in_process));			
	}
		
	virtual ReqProbeSelfGeneric* createReqSelfProbe(
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeSelfTCP(in_remote, in_process));		
	}
public:
	HandleGetDistanceTCP(const vector<NodeIdentRendv>& in_src,	
				const vector<NodeIdentRendv>& in_remote, 
				MeridianProcess* in_process, 
				u_int in_timeout_ms, uint64_t in_prevQID) 
		: HandleGetDistanceGeneric(in_src, in_remote, 
			in_process, in_timeout_ms, in_prevQID) {}
			
	virtual ~HandleGetDistanceTCP() {}
};



class HandleGetDistanceDNS : public HandleGetDistanceGeneric {
protected:	
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeDNS(in_src_node, in_remote, in_process));			
	}
		
	virtual ReqProbeSelfGeneric* createReqSelfProbe(
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeSelfDNS(in_remote, in_process));		
	}
public:
	HandleGetDistanceDNS(const vector<NodeIdentRendv>& in_src,	
				const vector<NodeIdentRendv>& in_remote, 
				MeridianProcess* in_process, 
				u_int in_timeout_ms, uint64_t in_prevQID) 
		: HandleGetDistanceGeneric(in_src, in_remote, 
			in_process, in_timeout_ms, in_prevQID) {}
			
	virtual ~HandleGetDistanceDNS() {}
};


class HandleGetDistancePing : public HandleGetDistanceGeneric {
protected:	
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbePing(in_src_node, in_remote, in_process));			
	}
		
	virtual ReqProbeSelfGeneric* createReqSelfProbe(
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeSelfPing(in_remote, in_process));		
	}
public:
	HandleGetDistancePing(const vector<NodeIdentRendv>& in_src,	
				const vector<NodeIdentRendv>& in_remote, 
				MeridianProcess* in_process, 
				u_int in_timeout_ms, uint64_t in_prevQID) 
		: HandleGetDistanceGeneric(in_src, in_remote, 
			in_process, in_timeout_ms, in_prevQID) {}
			
	virtual ~HandleGetDistancePing() {}
};

#ifdef PLANET_LAB_SUPPORT
class HandleGetDistanceICMP : public HandleGetDistanceGeneric {
protected:	
	virtual ReqProbeGeneric* createReqProbe(const NodeIdentRendv& in_src_node,
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeICMP(in_src_node, in_remote, in_process));			
	}
		
	virtual ReqProbeSelfGeneric* createReqSelfProbe(
			const set<NodeIdent, ltNodeIdent>& in_remote, 
			MeridianProcess* in_process) {
		return (new ReqProbeSelfICMP(in_remote, in_process));		
	}
public:
	HandleGetDistanceICMP(const vector<NodeIdentRendv>& in_src,	
				const vector<NodeIdentRendv>& in_remote, 
				MeridianProcess* in_process, 
				u_int in_timeout_ms, uint64_t in_prevQID) 
		: HandleGetDistanceGeneric(in_src, in_remote, 
			in_process, in_timeout_ms, in_prevQID) {}
			
	virtual ~HandleGetDistanceICMP() {}
};
#endif
#endif
#endif