コード例 #1
0
ConnectionInfo* TrackerMgr::GetConnectionByAddr(ServerAddress *pTrackerAddr)
{
	UINT32					nFlag;
	struct sockaddr_in		s_in;
	char					cIP[16];
	int	nDeqSize	= (int)m_deqConnectionInfo.size();
	UINT32 nRet;
	for(int i = 0; i < nDeqSize; i++)
	{
		ConnectionInfo *pConnectionInfo = m_deqConnectionInfo[i];
		if(pConnectionInfo->port == pTrackerAddr->nPort &&
			0 == strcmp(pConnectionInfo->ip_addr, (const char*)pTrackerAddr->szIP))
		{
			//将被置为Invalid的Socket进行重连
			if(pConnectionInfo->sock == INVALID_SOCKET)
			{
				nRet = ConnectToTracker(pConnectionInfo);
				if(nRet != enumSuccess_FDFS)
				{
					return NULL;
				}
			}
			return pConnectionInfo;
		}
	}
	
	//没有找到,就创建一个新的ConnectionInfo
	ConnectionInfo *pNew = new ConnectionInfo;
	if(pNew == NULL)
	{
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetConnectionByAddr New Error"));
		return NULL;
	}
	memset(pNew, 0, sizeof(ConnectionInfo));
	pNew->sock = INVALID_SOCKET;

	pNew->port = pTrackerAddr->nPort;
	memcpy_s(pNew->ip_addr, sizeof(pNew->ip_addr), pTrackerAddr->szIP, sizeof(pTrackerAddr->szIP));
	InitializeCriticalSection(&pNew->csRecv);
	InitializeCriticalSection(&pNew->csSend);

	nRet = ConnectToTracker(pNew);
	if(nRet == enumSuccess_FDFS)
	{
		EnterCriticalSection(&m_csOperation);
		m_deqConnectionInfo.push_back(pNew);
		LeaveCriticalSection(&m_csOperation);
		return pNew;
	}
	else
	{
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetConnectionByAddr ConnectToTracker Failed Server IP:%s, Port:%d"), pTrackerAddr->szIP, pTrackerAddr->nPort);
		DeleteCriticalSection(&pNew->csRecv);
		DeleteCriticalSection(&pNew->csSend);
		delete pNew;
		return NULL;
	}
}
コード例 #2
0
UINT32 TrackerMgr::ConnectToTracker(ConnectionInfo *pTrackerServer)
{
	UINT32					nFlag;
	struct sockaddr_in		s_in;
	char					cIP[16];
	
	EnterCriticalSection(&pTrackerServer->csSend);
	if(pTrackerServer->sock != INVALID_SOCKET)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
	}

	pTrackerServer->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(pTrackerServer->sock == INVALID_SOCKET)
	{
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::ConnectToTracker Socket Failed, %d"), WSAGetLastError());
		return enumFailure_FDFS;
	}

	_tcscpy_s(cIP, 16, pTrackerServer->ip_addr);
	s_in.sin_family			= AF_INET;
	s_in.sin_port			= htons((u_short)pTrackerServer->port);
	s_in.sin_addr.s_addr	= inet_addr(cIP);

	if(connect(pTrackerServer->sock, (struct sockaddr *)&s_in, sizeof(struct sockaddr)) == SOCKET_ERROR)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::ConnectToTracker Can't Connect Tracker Server IP:%s, Port:%d"), pTrackerServer->ip_addr, pTrackerServer->port);
		return enumNetworkError_FDFS;
	}

	nFlag = 1;
	if(ioctlsocket(pTrackerServer->sock, FIONBIO, (u_long*)&nFlag) == SOCKET_ERROR)   
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::ConnectToTracker ioctlsocket Failed"));
		return enumFailure_FDFS;
	}
	if(setsockopt(pTrackerServer->sock, IPPROTO_TCP, TCP_NODELAY,  (char *)&nFlag, sizeof(nFlag)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::ConnectToTracker setsockopt Failed"));
		return enumFailure_FDFS;
	}
	
	LeaveCriticalSection(&pTrackerServer->csSend);
	return enumSuccess_FDFS;
}
コード例 #3
0
bool CBaseThread::ForceTerminate()
{
	if(m_hThread)
	{
		BOOL bErrorCode = FALSE;
		bErrorCode = ::TerminateThread(m_hThread, -1);
		if(bErrorCode)
		{
			CloseHandle(m_hThread);
			m_hThread = NULL;
			m_bIsTerminate = true;

			return true;
		}

		int nErrorCode = GetLastError();
		CloseHandle(m_hThread);
		m_hThread = NULL;
		m_bIsTerminate = true;

		WriteLogInfo(LOG_INFO, _T("CBaseThread::ForceTerminate(), 强制关闭线程出错,错误代码:%d"), nErrorCode);
		return false;
	}

	return true;
}
コード例 #4
0
DWORD CBaseThread::SuspendThread()
{
	if(m_hThread)
	{
		int nErrorCode = 0;
		nErrorCode = ::SuspendThread(m_hThread);
		if(-1 != nErrorCode)
		{
			return nErrorCode;
		}

		nErrorCode = GetLastError();
		WriteLogInfo(LOG_INFO, _T("CBaseThread::SuspendThread(), 挂起正在运行的线程出错,错误代码:%d"), nErrorCode);
	}

	return -1;
}
コード例 #5
0
bool CBaseThread::BeginThread(bool bIsRun)
{
	if(NULL == m_hThread)
	{
		if(bIsRun)
			m_hThread = (HANDLE)_beginthreadex(NULL, 0, &CBaseThread::Execute, (PVOID)this, 0, NULL);
		else
			m_hThread = (HANDLE)_beginthreadex(NULL, 0, &CBaseThread::Execute, (PVOID)this, CREATE_SUSPENDED, NULL);

		if(m_hThread)
		{
			DoWriteLogInfo(LOG_DEBUG, _T("CBaseThread::CreateThreadInstance(), 创建子线程成功"));
			return true;
		}

		WriteLogInfo(LOG_INFO, _T("CBaseThread::CreateThreadInstance(), 创建子线程出错,错误代码:%d"), errno);
	}

	return false;			
}
コード例 #6
0
UINT32 TrackerMgr::Initialize(ServerAddress *pAddr, UINT32 nArrCount)
{
	UINT32 nRet;
	UINT32 nSuccess = 0;

	ServerAddress *pCurrentAddr = pAddr;
	nSuccess = 0;
	int i;
	for(i = 0; i < nArrCount; i++)
	{
		ConnectionInfo *pCurrentConn = new ConnectionInfo();
		pCurrentConn->port = pCurrentAddr->nPort;
		strcpy(pCurrentConn->ip_addr, (char*)pCurrentAddr->szIP);
		pCurrentConn->sock = INVALID_SOCKET;
		InitializeCriticalSection(&pCurrentConn->csRecv);
		InitializeCriticalSection(&pCurrentConn->csSend);
		nRet = ConnectToTracker(pCurrentConn);
		if(nRet != enumSuccess_FDFS)
		{
			WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::Initialize Connect Failed IP:%s, Port:%d, Return Code:%d"), pCurrentConn->ip_addr, pCurrentConn->port, nRet);
			DeleteCriticalSection(&pCurrentConn->csRecv);
			DeleteCriticalSection(&pCurrentConn->csSend);
			delete pCurrentConn;
		}
		else
		{
			nSuccess++;
			m_deqConnectionInfo.push_back(pCurrentConn);
		}
		pCurrentAddr++;
	}

	if(nSuccess > 0 || (pAddr == NULL || nArrCount == 0))
		return enumSuccess_FDFS;
	else
		return enumFailure_FDFS;
}
コード例 #7
0
UINT32 TrackerMgr::GetStorageStat(ConnectionInfo *pTrackerServer,
	TCHAR *pszGroupName, FDFSStorageStat *pStat, UINT32 nLen,
	UINT32 *pnStatCount)
{
	UINT32 nRet;
	UINT64 nInBytes;
	StorageStat rawStat[FDFS_MAX_GROUPS];
	BYTE byOut[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN];
	memset(byOut, 0, sizeof(byOut));
	memset(pStat, 0, sizeof(FDFSStorageStat) * nLen);
	UINT32 nNameLen = strlen(pszGroupName);
	if (nNameLen > FDFS_GROUP_NAME_MAX_LEN)
	{
		nNameLen = FDFS_GROUP_NAME_MAX_LEN;
	}

	TrackerHeader *pHeader = (TrackerHeader*)byOut;
	pHeader->byCmd = TRACKER_PROTO_CMD_SERVER_LIST_STORAGE;
	memcpy(byOut + sizeof(TrackerHeader), pszGroupName, nNameLen);
	long642buff(FDFS_GROUP_NAME_MAX_LEN, (char*)pHeader->byPkgLen);

	EnterCriticalSection(&pTrackerServer->csSend);
	if ((nRet = tcpsenddata_nb(pTrackerServer->sock, byOut, sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, DEFAULT_NETWORK_TIMEOUT)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	TrackerHeader resp;
	int nCount = 0;
	EnterCriticalSection(&pTrackerServer->csRecv);
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	if (resp.byStatus != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Status Error, %d"), resp.byStatus);
		return enumFailure_FDFS;
	}

	nInBytes = buff2long64((const char*)(resp.byPkgLen));
	if (nInBytes < 0 || (nInBytes % sizeof(StorageStat)) != 0 || (nInBytes / sizeof(StorageStat)) > FDFS_MAX_SERVERS_EACH_GROUP)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Packet Len Error"));
		return enumFailure_FDFS;
	}
	*pnStatCount = nInBytes / sizeof(StorageStat);

	//包头接收完毕,接收Body
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, rawStat, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}
	LeaveCriticalSection(&pTrackerServer->csRecv);
	LeaveCriticalSection(&pTrackerServer->csSend);

	//数据接收完毕,开始处理
	if(nLen < *pnStatCount)
	{
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetStorageStat Storages Is Too Many"));
		return enumFailure_FDFS;
	}
	
	StorageStatBuff *pStatBuff = NULL;
	StorageStat *pSrc = NULL;
	FDFSStorageInfo *pStorageInfo = NULL;
	FDFSStorageStat *pDest = NULL;

	for(int i = 0; i < *pnStatCount; i++)
	{
		pDest = &pStat[i];
		pSrc = &rawStat[i];
		pStatBuff = &(pSrc->statBuff);
		pStorageInfo = &(pDest->stat);

		pDest->byStatus = pSrc->byStatus;
		//保留最后一个\0
		memcpy(pDest->szID, pSrc->byID, FDFS_STORAGE_ID_MAX_SIZE - 1);
		memcpy(pDest->szIpAddr, pSrc->byIP, IP_ADDRESS_SIZE - 1);
		memcpy(pDest->szSrcId, pSrc->bySrcID, FDFS_STORAGE_ID_MAX_SIZE - 1);
		strcpy(pDest->szDomainName, (const char*)pSrc->byDomainName);
		strcpy(pDest->szVersion, (const char*)pSrc->byVersion);
		pDest->joinTime = buff2long64((const char*)pSrc->byJoinTime);
		pDest->upTime = buff2long64((const char*)pSrc->byUpTime);
		pDest->nTotalMb = buff2long64((const char*)pSrc->byTotalMB);
		pDest->nFreeMb = buff2long64((const char*)pSrc->byFreeMB);
		pDest->nUploadPriority = buff2long64((const char*)pSrc->byUploadPriority);
		pDest->nStorePathCount = buff2long64((const char*)pSrc->byStorePathCount);
		pDest->nSubdirCountPerPath = buff2long64((const char*)pSrc->bySubdirCountPerPath);
		pDest->nStoragePort = buff2long64((const char*)pSrc->byStoragePort);
		pDest->nStorageHttpPort = buff2long64((const char*)pSrc->byStorageHttpPort);
		pDest->nCurrentWritePath = buff2long64((const char*)pSrc->byCurrentWritePath);

		pStorageInfo->connection.nAllocCount = buff2int((const char*)pStatBuff->connection.byAllocCount);
		pStorageInfo->connection.nCurrentCount = buff2int((const char*)pStatBuff->connection.byCurrentCount);
		pStorageInfo->connection.nMaxCount = buff2int((const char*)pStatBuff->connection.byMaxCount);

		pStorageInfo->nTotalUploadCount = buff2long64((const char*)pStatBuff->byTotalUploadCount);
		pStorageInfo->nSuccessUploadCount = buff2long64((const char*)pStatBuff->bySuccessUploadCount);
		pStorageInfo->nTotalAppendCount = buff2long64((const char*)pStatBuff->byTotalAppendCount);
		pStorageInfo->nSuccessAppendCount = buff2long64((const char*)pStatBuff->bySuccessAppendCount);
		pStorageInfo->nTotalModifyCount = buff2long64((const char*)pStatBuff->byTotalModifyCount);
		pStorageInfo->nSuccessModifyCount = buff2long64((const char*)pStatBuff->bySuccessModifyCount);
		pStorageInfo->nTotalTruncateCount = buff2long64((const char*)pStatBuff->byTotalTruncateCount);
		pStorageInfo->nSuccessTruncateCount = buff2long64((const char*)pStatBuff->bySuccessTruncateCount);
		pStorageInfo->nTotalSetMetaCount = buff2long64((const char*)pStatBuff->byTotalSetMetaCount);
		pStorageInfo->nSuccessSetMetaCount = buff2long64((const char*)pStatBuff->bySuccessSetMetaCount);

		pStorageInfo->nTotalDeleteCount = buff2long64((const char*)pStatBuff->byTotalDeleteCount);
		pStorageInfo->nSuccessDeleteCount = buff2long64((const char*)pStatBuff->bySuccessDeleteCount);
		pStorageInfo->nTotalDownloadCount = buff2long64((const char*)pStatBuff->byTotalDownloadCount);
		pStorageInfo->nSuccessDownloadCount = buff2long64((const char*)pStatBuff->bySuccessDownloadCount);
		pStorageInfo->nTotalGetMetaCount = buff2long64((const char*)pStatBuff->byTotalGetMetaCount);
		pStorageInfo->nSuccessGetMetaCount = buff2long64((const char*)pStatBuff->bySuccessGetMetaCount);
		pStorageInfo->lastSourceUpdate = buff2long64((const char*)pStatBuff->byLastSourceUpdate);
		pStorageInfo->lastSyncUpdate = buff2long64((const char*)pStatBuff->byLastSyncUpdate);
		pStorageInfo->lastSyncedTimestamp = buff2long64((const char*)pStatBuff->byLastSyncedTimestamp);
		pStorageInfo->nTotalCreateLinkCount = buff2long64((const char*)pStatBuff->byTotalCreateLinkCount);
		pStorageInfo->nSuccessCreateLinkCount = buff2long64((const char*)pStatBuff->bySuccessCreateLinkCount);
		pStorageInfo->nTotalDeleteLinkCount = buff2long64((const char*)pStatBuff->byTotalDeleteLinkCount);
		pStorageInfo->nSuccessDeleteLinkCount = buff2long64((const char*)pStatBuff->bySuccessDeleteLinkCount);
		pStorageInfo->nTotalUploadBytes = buff2long64((const char*)pStatBuff->byTotalUploadBytes);
		pStorageInfo->nSuccessUploadBytes = buff2long64((const char*)pStatBuff->bySuccessUploadBytes);
		pStorageInfo->nTotalAppendBytes = buff2long64((const char*)pStatBuff->byTotalAppendBytes);
		pStorageInfo->nSuccessAppendBytes = buff2long64((const char*)pStatBuff->bySuccessAppendBytes);
		pStorageInfo->nTotalModifyBytes = buff2long64((const char*)pStatBuff->byTotalModifyBytes);
		pStorageInfo->nSuccessModifyBytes = buff2long64((const char*)pStatBuff->bySuccessModifyBytes);
		pStorageInfo->nTotalDownloadBytes = buff2long64((const char*)pStatBuff->byTotalDownloadBytes);
		pStorageInfo->nSuccessDownloadBytes = buff2long64((const char*)pStatBuff->bySuccessDownloadBytes);
		pStorageInfo->nTotalSyncInBytes = buff2long64((const char*)pStatBuff->byTotalSyncInBytes);
		pStorageInfo->nSuccessSyncInBytes = buff2long64((const char*)pStatBuff->bySuccessSyncInBytes);
		pStorageInfo->nTotalSyncOutBytes = buff2long64((const char*)pStatBuff->byTotalSyncOutBytes);
		pStorageInfo->nSuccessSyncOutBytes = buff2long64((const char*)pStatBuff->bySuccessSyncOutBytes);
		pStorageInfo->nTotalFileOpenCount = buff2long64((const char*)pStatBuff->byTotalFileOpenCount);
		pStorageInfo->nSuccessFileOpenCount = buff2long64((const char*)pStatBuff->bySuccessFileOpenCount);
		pStorageInfo->nTotalFileReadCount = buff2long64((const char*)pStatBuff->byTotalFileReadCount);
		pStorageInfo->nSuccessFileReadCount = buff2long64((const char*)pStatBuff->bySuccessFileReadCount);
		pStorageInfo->nTotalFileWriteCount = buff2long64((const char*)pStatBuff->byTotalFileWriteCount);
		pStorageInfo->nSuccessFileWriteCount = buff2long64((const char*)pStatBuff->bySuccessFileWriteCount);
		pStorageInfo->lastHeartBeatTime = buff2long64((const char*)pStatBuff->byLastHeartBeatTime);
		pDest->bIfTrunkServer = pSrc->byIfTrunkServer;
	}
	return enumSuccess_FDFS;
}
コード例 #8
0
UINT32 TrackerMgr::GetGroupStat(ConnectionInfo *pTrackerServer,
	FDFSGroupStat *pStat, UINT32 nLen, UINT32 *pnStatCount)
{
	UINT32 nRet;
	UINT64 nInBytes;
	memset(pStat, 0, sizeof(FDFSGroupStat) * nLen);
	GroupStat rawStat[FDFS_MAX_GROUPS];

	TrackerHeader header;
	memset(&header, 0, sizeof(header));
	header.byCmd = TRACKER_PROTO_CMD_SERVER_LIST_ALL_GROUPS;

	EnterCriticalSection(&pTrackerServer->csSend);
	if ((nRet = tcpsenddata_nb(pTrackerServer->sock, &header, sizeof(header), DEFAULT_NETWORK_TIMEOUT)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	TrackerHeader resp;
	int nCount = 0;
	EnterCriticalSection(&pTrackerServer->csRecv);
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	if (resp.byStatus != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat Status Error, %d"), resp.byStatus);
		return enumFailure_FDFS;
	}

	nInBytes = buff2long64((const char*)(resp.byPkgLen));
	if (nInBytes < 0 || (nInBytes % sizeof(GroupStat)) != 0 || (nInBytes / sizeof(GroupStat)) > FDFS_MAX_GROUPS)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat Packet Len Error"));
		return enumFailure_FDFS;
	}
	*pnStatCount = nInBytes / sizeof(GroupStat);

	//包头接收完毕,接收Body
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, rawStat, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}
	LeaveCriticalSection(&pTrackerServer->csRecv);
	LeaveCriticalSection(&pTrackerServer->csSend);

	//数据接收完毕,开始处理
	if(nLen < *pnStatCount)
	{
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::GetGroupStat Groups Is Too Many"));
		return enumFailure_FDFS;
	}
	for(int i = 0; i < *pnStatCount; i++)
	{
		memcpy(pStat[i].szGroupName, rawStat[i].szGroupName, FDFS_GROUP_NAME_MAX_LEN);
		pStat[i].nTotalMB = buff2long64((const char*)rawStat[i].byTotalMB);
		pStat[i].nFreeMB = buff2long64((const char*)rawStat[i].byFreeMB);
		pStat[i].nTrunkFreeMB = buff2long64((const char*)rawStat[i].byTrunkFreeMB);
		pStat[i].nCount = buff2long64((const char*)rawStat[i].byCount);
		pStat[i].nStoragePort = buff2long64((const char*)rawStat[i].byStoragePort);
		pStat[i].nStorageHttpPort = buff2long64((const char*)rawStat[i].byStorageHttpPort);
		pStat[i].nActiveCount = buff2long64((const char*)rawStat[i].byActiveCount);
		pStat[i].nCurrentWriteServer = buff2long64((const char*)rawStat[i].byCurrentWriteServer);
		pStat[i].nStorePathCount = buff2long64((const char*)rawStat[i].byStorePathCount);
		pStat[i].nSubdirCountPerPath = buff2long64((const char*)rawStat[i].bySubdirCountPerPath);
		pStat[i].nCurrentTrunkFileID = buff2long64((const char*)rawStat[i].byCurrentTrunkFileID);
	}
	return enumSuccess_FDFS;
}
コード例 #9
0
UINT32 TrackerMgr::QueryStorageFetch(ConnectionInfo *pTrackerServer,
	const BYTE *szGroupName, const BYTE *szRemoteFileName,
	ServerAddress *pStorageServer)
{
	UINT32 nRemoteFileNameLen;
	UINT32 nGroupNameLen;
	UINT32 nOutBytes = 0, nInBytes = 0;
	UINT32 nRet;
	BYTE *p = NULL;
	BYTE byOutBuff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + FDFS_REMOTE_FILE_NAME_MAX_LEN];
	TrackerHeader *pHeader;

	memset(byOutBuff, 0, sizeof(byOutBuff));
	pHeader = (TrackerHeader *)byOutBuff;
	p = byOutBuff + sizeof(TrackerHeader);

	nGroupNameLen = strlen((const char*)szGroupName);
	memcpy_s(p, sizeof(byOutBuff) - (p - byOutBuff), szGroupName, nGroupNameLen);
	p += FDFS_GROUP_NAME_MAX_LEN;

	nRemoteFileNameLen = strlen((const char*)szRemoteFileName);
	memcpy_s(p, sizeof(byOutBuff) - (p - byOutBuff), szRemoteFileName, nRemoteFileNameLen);
	p += nRemoteFileNameLen;

	nOutBytes = p - byOutBuff;
	long642buff(nOutBytes - sizeof(TrackerHeader), (char*)pHeader->byPkgLen);
	pHeader->byCmd = TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ONE;

	EnterCriticalSection(&pTrackerServer->csSend);
	if ((nRet = tcpsenddata_nb(pTrackerServer->sock, byOutBuff, nOutBytes, DEFAULT_NETWORK_TIMEOUT)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	//发包完毕,准备接收数据
	TrackerHeader resp;
	int nCount = 0;
	EnterCriticalSection(&pTrackerServer->csRecv);
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	if (resp.byStatus != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch Status Error, %d"), resp.byStatus);
		return enumFailure_FDFS;
	}

	nInBytes = buff2long64((const char*)(resp.byPkgLen));
	if (nInBytes < 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch Packet Len Error"));
		return enumFailure_FDFS;
	}

	//包头接收完毕,接收Body
	BYTE *pbyBuff = NULL;
	pbyBuff = new BYTE[nInBytes];
	if(pbyBuff == NULL)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch New Error"));
		delete[] pbyBuff;
		return enumFailure_FDFS;
	}
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, pbyBuff, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageFetch tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
		delete[] pbyBuff;
		return enumNetworkError_FDFS;
	}
	LeaveCriticalSection(&pTrackerServer->csRecv);
	LeaveCriticalSection(&pTrackerServer->csSend);

	//数据接收完毕,开始解析
	//前16字节为Group Name,用不着
	//memcpy(szGroupName, pbyBuff, FDFS_GROUP_NAME_MAX_LEN);
	//*(szGroupName + FDFS_GROUP_NAME_MAX_LEN) = '\0';
	memcpy(pStorageServer->szIP, pbyBuff + FDFS_GROUP_NAME_MAX_LEN, IP_ADDRESS_SIZE - 1);
	pStorageServer->nPort = buff2long64((const char*)(pbyBuff + FDFS_GROUP_NAME_MAX_LEN + IP_ADDRESS_SIZE - 1));
	delete[] pbyBuff;
	return enumSuccess_FDFS;
}
コード例 #10
0
UINT32 TrackerMgr::QueryUpdateStorageStore(ConnectionInfo *pTrackerServer,
		const BYTE *pbyMasterGroupName, const BYTE *pbyMasterFileName,
		ServerAddress *pStorageServer,
		UINT32 *nStorePathIndex)
{
	UINT32 nRet;
	UINT64 nInBytes;

	BYTE byOutBuff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN
	+ FDFS_REMOTE_FILE_NAME_MAX_LEN];
	memset(byOutBuff, 0, sizeof(byOutBuff));

	TrackerHeader *pHeader = (TrackerHeader*)byOutBuff;
	memcpy(byOutBuff + sizeof(TrackerHeader), pbyMasterGroupName, FDFS_GROUP_NAME_MAX_LEN);

	UINT32 nMasterFileNameLen = strlen((const char*)pbyMasterFileName);
	memcpy(byOutBuff + sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN, pbyMasterFileName, nMasterFileNameLen);
	long642buff(FDFS_GROUP_NAME_MAX_LEN + nMasterFileNameLen, (char*)pHeader->byPkgLen);
	pHeader->byCmd = TRACKER_PROTO_CMD_SERVICE_QUERY_UPDATE;

	EnterCriticalSection(&pTrackerServer->csSend);
	if ((nRet = tcpsenddata_nb(pTrackerServer->sock, &byOutBuff, sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN + nMasterFileNameLen, DEFAULT_NETWORK_TIMEOUT)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	TrackerHeader resp;
	int nCount = 0;
	EnterCriticalSection(&pTrackerServer->csRecv);
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	if (resp.byStatus != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore Status Error, %d"), resp.byStatus);
		return enumFailure_FDFS;
	}

	nInBytes = buff2long64((const char*)(resp.byPkgLen));
	if (nInBytes < 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore Packet Len Error"));
		return enumFailure_FDFS;
	}

	//包头接收完毕,接收Body
	BYTE *pbyBuff = NULL;
	pbyBuff = new BYTE[nInBytes];
	if(pbyBuff == NULL)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore New Error"));
		delete[] pbyBuff;
		return enumFailure_FDFS;
	}
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, pbyBuff, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryUpdateStorageStore tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
		delete[] pbyBuff;
		return enumNetworkError_FDFS;
	}
	LeaveCriticalSection(&pTrackerServer->csRecv);
	LeaveCriticalSection(&pTrackerServer->csSend);
	
	//数据接收完毕,开始解析
	memcpy(pStorageServer->szIP, pbyBuff + FDFS_GROUP_NAME_MAX_LEN, IP_ADDRESS_SIZE - 1);
	pStorageServer->nPort = buff2long64((const char*)(pbyBuff + FDFS_GROUP_NAME_MAX_LEN + IP_ADDRESS_SIZE - 1));

	delete[] pbyBuff;

	return enumSuccess_FDFS;
}
コード例 #11
0
//recv不做重连
UINT32 TrackerMgr::QueryStorageStore(ConnectionInfo *pTrackerServer,
		ServerAddress *pStorageServer,
		TCHAR *szGroupName, UINT32 *nStorePathIndex)
{
	UINT32 nRet;
	UINT64 nInBytes;

	TrackerHeader header;
	memset(&header, 0, sizeof(header));
	header.byCmd = TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE;

	EnterCriticalSection(&pTrackerServer->csSend);
	if ((nRet = tcpsenddata_nb(pTrackerServer->sock, &header, sizeof(header), DEFAULT_NETWORK_TIMEOUT)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore tcpsenddata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	TrackerHeader resp;
	int nCount = 0;
	EnterCriticalSection(&pTrackerServer->csRecv);
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, &resp, sizeof(resp), DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore tcprecvdata_nb Header Failed, Error Code:%d"), nRet);
		return enumNetworkError_FDFS;
	}

	if (resp.byStatus != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore Status Error, %d"), resp.byStatus);
		if(resp.byStatus == 28)
			return enumNoEnoughSpace_FDFS;
		return enumFailure_FDFS;
	}

	nInBytes = buff2long64((const char*)(resp.byPkgLen));
	if (nInBytes < 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore Packet Len Error"));
		return enumFailure_FDFS;
	}

	//包头接收完毕,接收Body
	BYTE *pbyBuff = NULL;
	pbyBuff = new BYTE[nInBytes];
	if(pbyBuff == NULL)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore New Error"));
		delete[] pbyBuff;
		return enumFailure_FDFS;
	}
	if ((nRet = tcprecvdata_nb(pTrackerServer->sock, pbyBuff, nInBytes, DEFAULT_NETWORK_TIMEOUT, &nCount)) != 0)
	{
		closesocket(pTrackerServer->sock);
		pTrackerServer->sock = INVALID_SOCKET;
		LeaveCriticalSection(&pTrackerServer->csRecv);
		LeaveCriticalSection(&pTrackerServer->csSend);
		WriteLogInfo(LogFileName, FDFSC_ERROR_MODE, _T("TrackerMgr::QueryStorageStore tcprecvdata_nb Body Failed, Error Code:%d"), nRet);
		delete[] pbyBuff;
		return enumNetworkError_FDFS;
	}
	LeaveCriticalSection(&pTrackerServer->csRecv);
	LeaveCriticalSection(&pTrackerServer->csSend);
	
	//数据接收完毕,开始解析
	memcpy(szGroupName, pbyBuff, FDFS_GROUP_NAME_MAX_LEN);
	*(szGroupName + FDFS_GROUP_NAME_MAX_LEN) = '\0';
	memcpy(pStorageServer->szIP, pbyBuff + FDFS_GROUP_NAME_MAX_LEN, IP_ADDRESS_SIZE - 1);
	pStorageServer->nPort = buff2long64((const char*)(pbyBuff + FDFS_GROUP_NAME_MAX_LEN + IP_ADDRESS_SIZE - 1));
	*nStorePathIndex = *(pbyBuff + FDFS_GROUP_NAME_MAX_LEN + IP_ADDRESS_SIZE - 1 + FDFS_PROTO_PKG_LEN_SIZE);

	delete[] pbyBuff;

	return enumSuccess_FDFS;
}