示例#1
0
void ServerConnection::queueFrame(quint32 frameNumber, QByteArray frameData)
{
    Frame f(frameNumber, frameData);

    // append to queue of this connection
    m_frameQueue.append(f);

    if( m_frameNumbersInFlight.size() < MAX_FRAMES_IN_FLIGHT )
    {
        sendData();
    }

    // we start dropping frames when the queue is at MAX_FRAME_QUEUE
    // unless we are set to lossless, then we
    // give the server a signal to throttle
    if(m_frameQueue.size() > MAX_FRAME_QUEUE)
    {
        if( m_lossless )
        {
            if( !m_waiting )
            {
                m_waiting = true;
                emit waitingOnClient(this, m_waiting);
            }
        }
        else
        {
            // drop the oldest frame
            Frame f = m_frameQueue.takeFirst();
            qDebug() << "Connection " << m_tcpSocket->peerAddress().toString() << ":"
                     << m_tcpSocket->peerPort() << " dropped frame " << f.serial;
        }
    }
    emit scheduleSend();
}
示例#2
0
void ServerConnection::queueFrame(quint32 frameNumber, QByteArray frameData)
{
    if( m_tcpSocket == 0 )
        return;

    Frame f(frameNumber, frameData);

    // append to queue of this connection
    m_frameQueue.append(f);

    if( m_frameNumbersInFlight.size() < m_maxFramesInFlight )
    {
        sendData();
    }

    // we start dropping frames when the queue is at m_maxFramesInQueue
    // unless we are set to lossless, then we
    // give the server a signal to throttle

        // check if they are too old
        /*if(m_frameQueue.size() > m_maxFramesInQueue)
        {
            while( m_frameQueue.size() > 0 )
            {
                const Frame& f = m_frameQueue.first();

                if( f.time.elapsed() < 5000 )
                        break;

                qWarning() << tr("Frame %1 timed out after %2 msecs.").arg(f.serial).arg(f.time.elapsed());
                m_frameQueue.removeFirst();
            }
        }*/

    if(m_frameQueue.size() > m_maxFramesInQueue)
    {
        if( m_lossless )
        {
            if( !m_waiting )
            {
                m_waiting = true;
                emit waitingOnClient(this, m_waiting);
            }
        }
        else
        {
            // drop the oldest frame
            Frame f = m_frameQueue.takeFirst();
			if (getAcknowledgeNeeded())
            {
				qDebug() << "Connection " << m_tcpSocket->peerAddress().toString() << ":"
                     << m_tcpSocket->peerPort() << " dropped frame " << f.serial;
			}
        }
    }
    emit scheduleSend();
}
示例#3
0
void ServerConnection::ackFrame(quint32 serial)
{
    quint32 expectedSerial = m_frameNumbersInFlight.takeFirst();
    if( expectedSerial != serial )
    {
        qWarning() << "Ack received for frame " << serial << " while expected frame " << expectedSerial << ".";

        if( m_lossless && m_waiting )
        {
            m_waiting = false;
            emit waitingOnClient(this, m_waiting);
        }
    }
}
void ServerConnection::ackFrame(quint32 serial)
{
    if( m_frameNumbersInFlight.isEmpty() )
    {
        qWarning() << "Ignoring ack received for frame " << serial << " while no ack was expected.";
        return;
    }
    quint32 expectedSerial = m_frameNumbersInFlight.first();
    if( expectedSerial == serial )
    {
        m_frameNumbersInFlight.removeFirst();
    }
    else
    {
        qWarning() << "Ignoring ack received for frame " << serial << " while expected frame " << expectedSerial << ".";
    }

    if( m_lossless && m_waiting )
    {
        m_waiting = false;
        emit waitingOnClient(this, m_waiting);
    }
}
void ServerConnection::sendData()
{
    if( m_tcpSocket == 0 ||
        m_tcpSocket->state() != QAbstractSocket::ConnectedState )
    {
        return;
    }

    if( m_waiting )
        return;

//    if( m_tcpSocket->bytesToWrite() > MAX_BYTES_TO_WRITE )
//    {
//        m_waiting = true;
//        emit waitingOnClient(this, m_waiting);
//        return;
//    }

    bool overflow = false;
    while(!( m_frameNumbersInFlight.size() >= m_maxFramesInFlight ||
             m_frameQueue.isEmpty() ||
             overflow ))
    {
        Frame& f = m_frameQueue.first();
        if( f.sent == 0 )
        {
            qint64 bytesSent = m_tcpSocket->write(f.bytes);
            if( bytesSent < f.bytes.size() )
            {
                if( bytesSent != -1 )
                    f.sent = bytesSent;
                else
                    overflow = true;
            }
            else
            {
                m_frameNumbersInFlight.append(f.serial);
                m_frameQueue.removeFirst();
            }
        }
        else
        {
            const char* ptr = f.bytes.data();
            ptr += f.sent;
            qint64 len = f.bytes.size() - f.sent;

            qint64 bytesSent = m_tcpSocket->write(ptr, len);

            if( bytesSent < len )
            {
                if( bytesSent != -1 )
                    f.sent = f.sent + bytesSent;
                else
                    overflow = true;
            }
            else
            {
                m_frameNumbersInFlight.append(f.serial);
                m_frameQueue.removeFirst();
            }
        }

        if( overflow )
        {
            m_waiting = true;
            emit waitingOnClient(this, m_waiting);
        }
    }
}