コード例 #1
0
ファイル: KadOperation.cpp プロジェクト: 0vermind/NeoLoader
void CKadOperation::ProxyingResponse(CKadNode* pNode, CComChannel* pChannel, const string &Error)
{
	if(m_LookupHistory)
		m_LookupHistory->RegisterResponse(pNode->GetID());

	SOpProgress* pProgress = GetProgress(pNode);
	if(!pProgress)
		return;

	pProgress->uTimeOut = -1;

	if(!Error.empty())
	{
		pProgress->Shares = 0;
		pProgress->OpState = eOpFailed;

		LogLine(LOG_DEBUG, L"Recived error: '%S' on proxy lookup", Error.c_str());
	}
	else
	{
		pProgress->OpState = eOpProxy;

		if(m_pOperator && m_pOperator->IsValid())
			m_pOperator->OnProxyNode(pNode);

		SendRequests(pNode, pChannel, pProgress, false);
	}
}
コード例 #2
0
ファイル: KadOperation.cpp プロジェクト: 0vermind/NeoLoader
void CKadOperation::RequestStateless(CKadNode* pNode, CComChannel* pChannel, SOpProgress* pProgress)
{
	pProgress->OpState = eOpStateless;
	pProgress->Shares = 1;

	if(m_pOperator)
		m_pOperator->AddNode(pNode);

	SendRequests(pNode, pChannel, pProgress, true);
}
コード例 #3
0
ファイル: main.c プロジェクト: effection/ps2rd
static void QueueHandler ( void ) {

 SendRequests ();

 if ( iSendReq >= 0 ) {

  iSignalSema ( iSendReq );
  iSendReq = 0x80000000;

 }  /* end if */

}  /* end QueueHandler */
コード例 #4
0
ファイル: ldap.cpp プロジェクト: Robby-/anope
	void Run() override
	{
		while (!this->GetExitState())
		{
			this->Lock();
			/* Queries can be non empty if one is pushed during SendRequests() */
			if (queries.empty())
				this->Wait();
			this->Unlock();

			SendRequests();
		}
	}
コード例 #5
0
ファイル: KadOperation.cpp プロジェクト: 0vermind/NeoLoader
void CKadOperation::Process(UINT Tick)
{
	bool bLookupActive = m_LookupState == eLookupActive;

	CKadLookup::Process(Tick); // this looks for more nodes

	if(m_pOperator && m_pOperator->IsValid())
	{
		m_pOperator->RunTimers();

		if(bLookupActive && m_LookupState != eLookupActive)
			m_pOperator->OnClosestNodes();
	}

	if((Tick & E10PerSec) == 0)
		return;

	if(m_LookupState == eLookupActive)
		return; // we are looking for closer nodes right now - just wait a second
	

	// Note: the kad operation mode for this kind of lookups is complicated, there are 3 modes of operation
	//
	//		m_JumpCount > 0
	//	1. Jumping, where we open channels to random nodes and request proxying
	//
	//		m_HopLimit > 1
	//	2. Routing, where we open channels to propabalistically choosen closest nodes
	//				The propabalistically choice is based on the total desired spread area
	//				If we hit a node that is already handling this lookup we need to choose a new one
	//
	//		m_HopLimit == 1
	//	3. Itterative Mode, here we do a normal lookup for closest nodes and than talk to them, not using proxying
	//		
	//
	//		m_HopLimit == 0
	//	4. Target for a operations and messaging, not doing any own spreading
	//

	if(m_HopLimit == 0 || (m_HopLimit == 1 && !(CountCalls() || CountStores() || CountLoads())))
		return; // we are not alowed to do anything - hoop 0 or hoop 1 and we have no hopable jobs just messages

	int FailedCount = 0;
	// Note: if we are in range we will act as one successfull share
	int UsedShares = m_InRange ? 1 : 0;
	int ShareHolders = 0;
	for(TNodeStatusMap::iterator I = m_Nodes.begin(); I != m_Nodes.end(); I++)
	{
		SOpProgress* pProgress = (SOpProgress*)I->second;
		if(pProgress->OpState == eOpFailed)
		{
			FailedCount++;
			continue;
		}
		if(pProgress->Shares == 0)
			continue;
		
		if(!I->first.pChannel)
		{
			ASSERT(0);
			continue;
		}

		UsedShares += pProgress->Shares;
		ShareHolders++;

		bool bStateless;
		if(!((bStateless = (pProgress->OpState == eOpStateless)) || pProgress->OpState == eOpProxy))
			continue;

		// send newly added requests if there are any
		if (pProgress->Calls.size() != CountCalls()
		 || pProgress->Stores.size() != CountStores()
		 || pProgress->Loads.size() != CountLoads())
		{
			SendRequests(I->first.pNode, I->first.pChannel, pProgress, bStateless);
		}
	}
	int FreeShares = GetSpreadShare() - UsedShares;
	//ASSERT(FreeShares >= 0);
	m_ActiveCount = ShareHolders;
	m_FailedCount = FailedCount;


	int TotalDoneJobs = 0;
	int TotalReplys = 0;
	if(m_pOperator)
		CountDone(m_pOperator->GetRequests(), TotalDoneJobs, TotalReplys);
	else
		CountDone(m_CallMap, TotalDoneJobs, TotalReplys);
	CountDone(m_StoreMap, TotalDoneJobs, TotalReplys);
	CountDone(m_LoadMap, TotalDoneJobs, TotalReplys);
	m_TotalDoneJobs = TotalDoneJobs;
	m_TotalReplys = TotalReplys;


	if(m_ManualMode)
		return;

	// Note: if we are in Jump Mode we prep the iterator to give uss randome nodes
	//		If we are in Iterative Mode we prep the iterator to give us the closest node
	//		If we are in Routong Mode it complicated, we want a random node from the m_SpreadCount closest nodes
	CRoutingZone::SIterator Iter(m_JumpCount > 0 ? 0 : (m_HopLimit > 1 ? m_SpreadCount : 1));
	for(CKadNode* pNode = NULL; FreeShares > 0 && (pNode = GetParent<CKademlia>()->Root()->GetClosestNode(Iter, m_ID)) != NULL;)
	{
		if(m_JumpCount == 0 && ((pNode->GetID() ^ m_ID) > GetParent<CKademlia>()->Root()->GetMaxDistance()))
			break; // there are no nodes anymore in list that would be elegable here
		
		CComChannel* pChannel = GetChannel(pNode);
		if(!pChannel)
			continue;

		SOpProgress* pProgress = GetProgress(pNode);
		ASSERT(pProgress); // right after get channel this must work
		if(pProgress->OpState != eNoOp)
			continue; // this node has already been tryed

		if(m_HopLimit > 1)
			RequestProxying(pNode, pChannel, pProgress, FreeShares, ShareHolders, m_InitParam);
		else
			RequestStateless(pNode, pChannel, pProgress);

		if(pProgress->Shares)
		{
			FreeShares -= pProgress->Shares;
			ShareHolders ++;
		}
	}

	// if there are shares left we are out of nodes
	m_OutOfNodes = (FreeShares > 0);
}
コード例 #6
0
ファイル: NCSJPCEcwpIOStream.cpp プロジェクト: forostm/libecw
void CNCSJPCEcwpIOStream::ProcessReceivedPackets()
{
	Lock();
	while(m_ReceivedPackets.size()) {
		ReceivedPacket *pRP = *(m_ReceivedPackets.begin());
		NCSPacket *pPacket = pRP->pPacket;
		INT32 nLength = pRP->nLength;

		m_ReceivedPackets.remove(pRP);
		NCSFree(pRP);

		if( pPacket ) {
			UINT32		iPacketSize;
			NCSPacketType ptType;
			NCSClientUID	nClientUID;

			// have a valid file, so now unpack the blocks read
			NCS_PACKET_UNPACK_BEGIN(pPacket);
			NCS_PACKET_UNPACK_ELEMENT(iPacketSize);
			NCS_PACKET_UNPACK_ELEMENT(nClientUID);
			NCS_PACKET_UNPACK_ELEMENT(ptType);

			switch( ptType ) {
				case NCSPT_BLOCKS: 
					{
						UINT16 nBlocks;
						UINT32 i;

						NCS_PACKET_UNPACK_ELEMENT(nBlocks);
						/*
						** Unpack block data
						*/
						for(i = 0; i < nBlocks; i++) {
							NCSBlockId nBlock;
							UINT32 nBlockLength;
							UINT8 *pImage;
							NCS_PACKET_UNPACK_ELEMENT(nBlock);
							NCS_PACKET_UNPACK_ELEMENT(nBlockLength);
							pImage = (UINT8*)NCSMalloc(nBlockLength, FALSE);
							NCS_PACKET_UNPACK_ELEMENT_SIZE(pImage[0], nBlockLength);
//char buf[1024];
//sprintf(buf, "Packet %ld size %ld (", nBlock, nBlockLength);
//for(int v = 0; v < NCSMin(20, nBlockLength); v++) {
//	sprintf(buf + strlen(buf), "0x%lx,", pImage[v]);
//}
//sprintf(buf + strlen(buf), ")\r\n");
//OutputDebugStringA(buf);
	//						m_pJPC->Lock();
							if(GetPacketStatus(nBlock) == CNCSJPCPacketStatus::REQUESTED) {
								SetPacketStatus(nBlock, CNCSJPCPacketStatus::RECEIVED);
								CNCSJPCProgression p;
								p.m_nCurPacket = nBlock;
								CNCSJPCPacket *pHeader = m_pJPC->GetPacketHeader(nBlock);

								if(pHeader && m_pJPC->FindPacketRCPL(nBlock, p.m_nCurTile, p.m_nCurResolution, p.m_nCurComponent, p.m_nCurPrecinctX, p.m_nCurPrecinctY, p.m_nCurLayer)) {
									CNCSJPCEcwpIOStream Stream(m_pJPC, true);
									if(((CNCSJPCMemoryIOStream&)Stream).Open(pImage, nBlockLength) == NCS_SUCCESS) {
										pImage = NULL;
										pHeader->ParseHeader(*m_pJPC, Stream, &p);
										Stream.Close();
									}
								}
								delete pHeader;
							}
	//						m_pJPC->UnLock();
							NCSFree(pImage);
						}
					}
					break;

				case NCSPT_FLOW_CONTROL:
						// NOTUSED
					break;

				case NCSPT_SYNCHRONISE: /* [03] */
						{
	//						m_pJPC->Lock();
							if(m_bSendInProgress == false) {
								CNCSJPCPacketStatusIterator pCur = m_Packets.begin();
								CNCSJPCPacketStatusIterator pEnd = m_Packets.end();

								while(pCur != pEnd) {
									UINT32 nBlock = (*pCur).second.m_nPacket; 
									if((*pCur).second.m_eStatus == CNCSJPCPacketStatus::REQUESTED) {
										SetPacketStatus(nBlock, CNCSJPCPacketStatus::NONE);
										pCur = m_Packets.begin();
										CNCSJPCProgression p;
										p.m_nCurPacket = nBlock;
										if(m_pJPC->FindPacketRCPL(nBlock, p.m_nCurTile, p.m_nCurResolution, p.m_nCurComponent, p.m_nCurPrecinctX, p.m_nCurPrecinctY, p.m_nCurLayer)) {
											CNCSJPCTilePartHeader *pMainTP = m_pJPC->GetTile(p.m_nCurTile);
											RequestPrecinct((CNCSJPCPrecinct*)pMainTP->m_Components[p.m_nCurComponent]->m_Resolutions[p.m_nCurResolution]->m_Precincts.find(p.m_nCurPrecinctX, p.m_nCurPrecinctY));
										}
									}
									pCur++;
								}
							}
							SendRequests();
		//					m_pJPC->UnLock();
						}
					break;

				default:
						// ERROR unknown packet - ignore it
					break;
			}

			NCS_PACKET_UNPACK_END(pPacket);
			NCSFree(pPacket);
		}
	}
	UnLock();
}