unsigned Listener::Process()
{
	//Profile profile("Listener::Process");
    ////////////////////////////////////////
    //  handle inactive state (with UdpManager)
    if (!IsActive() && mTcpManager)
    {
		//	check all connections to see if they are idle
		std::set<Connection *>::iterator iterator;
		for (iterator = mConnections.begin(); iterator != mConnections.end(); iterator++)
		{
			Connection * connection = *iterator;
			if (connection->IsConnected())
				connection->Disconnect();
		}
		//	close the UdpManager if all the connections are closed
		if (!mConnectionCount)
		{
			mTcpManager->Release();
			mTcpManager = 0;
			OnShutdown();
		}
    }
    ////////////////////////////////////////
    //  handle active state (without UdpManager)
    else if (IsActive() && !mTcpManager)
    {
		mParams = GetConnectionParams();
        mActiveMax = GetActiveRequestMax();
        mTcpManager = new TcpManager(mParams);
		mTcpManager->SetHandler(this);
		if (mTcpManager->BindAsServer()){
            OnStartup();
        }else{
            OnFailedStartup();
            return 0;
        }
    }

    ////////////////////////////////////////
    //  process the TcpManager
    if (mTcpManager)
    {
		//Profile subProfile("TcpManager::GiveTime()");
        mTcpManager->GiveTime();
    }

	//	check all closed connections to see if they are idle
	std::list<Connection *>::iterator closedIterator = mClosedConnections.begin();
	while (closedIterator != mClosedConnections.end())
	{
		//Profile profile("Listener::Process (cleanup connection)");
		std::list<Connection *>::iterator current = closedIterator++;
		Connection * connection = *current;
		if (!connection->GetActiveRequests() && 
			!connection->GetQueuedRequests())
		{
			mClosedConnections.erase(current);
			mConnections.erase(connection);
			mConnectionCount--;
			OnConnectionDestroyed(connection);
			delete connection;
		}
	}

    ////////////////////////////////////////
    //  process request queue
    while (!mQueuedRequests.empty() && (!mActiveMax || mActiveCount < mActiveMax))
    {
		//Profile profile("Listener::Process (activate queued request)");
        QueueNode & node = mQueuedRequests.front();
        if (!IsActive())
        {
            //  If not active, discard queued request
            if (node.connection)
            {
                // normal request, internal requests have no connection
                node.connection->NotifyDiscardRequest(node.request);
            }
            DestroyRequest(node.request);
        }
        else
        {
            //  Move request to active list
            if (node.connection)
            {
                // normal request, internal requests have no connection
                node.connection->NotifyBeginRequest(node.request);
            }
            mActiveRequests.push_back(node);
			mActiveCount++;
        }
        mQueuedRequests.pop_front();
    }

    ////////////////////////////////////////
    //  Process active requests
    unsigned requestsProcessed = 0;
    std::list<QueueNode>::iterator iterator = mActiveRequests.begin();
    while (iterator != mActiveRequests.end())
    {
		//Profile profile("Listener::Process (process request)");
        std::list<QueueNode>::iterator current = iterator++;
        RequestBase * request = current->request;
        Connection * connection = current->connection;
    
        if (request->Process())
        {
            if (connection)
            {
                // normal request, internal requests have no connection
                connection->NotifyEndRequest(request);
            }
            DestroyRequest(request);
            mActiveRequests.erase(current);
			mActiveCount--;
        }
		else if (mSleepingRequests.find(request) != mSleepingRequests.end())
		{
            mActiveRequests.erase(current);
		}
	    requestsProcessed++;
    }
    return requestsProcessed;
}
Exemple #2
0
int32 TCPManager::_Manager_Thread() {
//	set_alarm(25000,B_PERIODIC_ALARM);
	Connection *connection;
	int32 connect_count;
	int32 current_time;
//	int32 last_used;
	
	int32 time_out=DEFAULT_TIMEOUT;
	
	while(!_quitter_) {
//		if (acquire_sem(process_sem_1)==B_OK) {
//			printf("processing\n");
			connect_count=Connection::CountConnections();
			
			if (connect_count>0) {
				current_time=real_time_clock();
				for (int32 i=0; i<connect_count; i++) {
					
					if (lock.LockWithTimeout(25000)==B_OK)
					{
//						printf("TCP Manager: lock acquired\n");
						connection=Connection::ConnectionAt(i);
						if (!Connection::HasConnection(connection))
						{
							lock.Unlock();
							snooze(10000);
							continue;
						}
						if (connection->IsConnected())
						{
							if (connection->IsInUse())
							{
								if (!connection->NotifiedConnect())
								{
									if (!connection->already_connected)
										connection->ConnectionEstablished();
									connection->NotifyConnect();
								} else
								{
									if (connection->IsDataWaiting())
									{
										connection->RetrieveData();
										if (connection->owner!=NULL)
											connection->owner->DataIsWaiting(connection);
									}
								}
							} else
							{
								if (connection->IsDataWaiting())
								{
//									printf("TCP Manager: data is waiting on unused connection; receiving and flushing data\n");
									int32 lastused=connection->LastUsed();
									connection->RetrieveData();
									connection->lastusedtime=lastused;
								}
							}
							if ((connection->LastUsed()!=0) && ((current_time-connection->LastUsed())>=time_out))
							{
//								if (connection->owner!=NULL)
//									connection->owner->DestroyingConnectionObject(connection);
								connection->TimeOut();
								Disconnect(connection);
							}
						} else
						{
							if (!connection->NotifiedDisconnect())
							{
								connection->NotifyDisconnect();
//								Disconnect(connection);
							}
							else
							{
								if ((connection->LastUsed()!=0) && ((current_time-connection->LastUsed())>=time_out))
								{
//									if (connection->owner!=NULL)
//										connection->owner->DestroyingConnectionObject(connection);
									connection->TimeOut();
									Disconnect(connection);
								}
							}
						}
						lock.Unlock();
					}
					snooze(10000);
				}
				
			}
			snooze(25000);
//			release_sem(process_sem_2);
//		}
			
	}
//	set_alarm(B_INFINITE_TIMEOUT,B_PERIODIC_ALARM);
	atomic_add(&Connection::SystemReady,-1);
	
	return 0;
}