void BlobResourceHandle::consumeData(const char* data, int bytesRead)
{
    ASSERT(m_async);

    m_totalRemainingSize -= bytesRead;

    // Notify the client.
    if (bytesRead)
        notifyReceiveData(data, bytesRead);

    if (m_fileOpened) {
        // When the current item is a file item, the reading is completed only if bytesRead is 0.
        if (!bytesRead) {
            // Close the file.
            m_fileOpened = false;
            m_asyncStream->close();

            // Move to the next item.
            m_readItemCount++;
        }
    } else {
        // Otherwise, we read the current text item as a whole and move to the next item.
        m_readItemCount++;
    }

    // Continue the reading.
    readAsync();
}
void BlobResourceHandle::getSizeForNext()
{
    // Do we finish validating and counting size for all items?
    if (m_sizeItemCount >= m_blobData->items().size()) {
        seek();

        // Start reading if in asynchronous mode.
        if (m_async) {
            notifyResponse();
            m_buffer.resize(bufferSize);
            readAsync();
        }
        return;
    }

    const BlobDataItem& item = m_blobData->items().at(m_sizeItemCount);
    switch (item.type) {
    case BlobDataItem::Data:
        didGetSize(item.length);
        break;
    case BlobDataItem::File:
        if (m_async)
            m_asyncStream->getSize(item.path, item.expectedModificationTime);
        else
            didGetSize(m_stream->getSize(item.path, item.expectedModificationTime));
        break;
    default:
        ASSERT_NOT_REACHED();
    }
}
Example #3
0
void BlobResourceHandle::getSizeForNext()
{
    ASSERT(isMainThread());

    // Do we finish validating and counting size for all items?
    if (m_sizeItemCount >= m_blobData->items().size()) {
        seek();

        // Start reading if in asynchronous mode.
        if (m_async) {
            Ref<BlobResourceHandle> protect(*this);
            notifyResponse();
            m_buffer.resize(bufferSize);
            readAsync();
        }
        return;
    }

    const BlobDataItem& item = m_blobData->items().at(m_sizeItemCount);
    switch (item.type) {
    case BlobDataItem::Data:
        didGetSize(item.length());
        break;
    case BlobDataItem::File:
        // Files know their sizes, but asking the stream to verify that the file wasn't modified.
        if (m_async)
            m_asyncStream->getSize(item.file->path(), item.file->expectedModificationTime());
        else
            didGetSize(m_stream->getSize(item.file->path(), item.file->expectedModificationTime()));
        break;
    default:
        ASSERT_NOT_REACHED();
    }
}
void BlobResourceHandle::didOpen(bool success)
{
    ASSERT(m_async);

    if (!success) {
        failed(notReadableError);
        return;
    }

    // Continue the reading.
    readAsync();
}
Example #5
0
    void MasterNodeConnection::didAccept()
	{
		auto self = shared_from_this();
        std::lock_guard<ioMutexType> lock(mutex);

        accepted = true;
		log.setChannel(str(format("Unknown [%s]") % tcpSocket().remote_endpoint()));

        auto headerBuffer = std::make_shared<std::uint32_t>();

        readAsync(asio::buffer(headerBuffer.get(), 4),
        [this, headerBuffer]
        (const boost::system::error_code& error, std::size_t readCount){
            try {
                if (error) {
                    MSCThrow(boost::system::system_error(error));
                }

                std::uint32_t header = *headerBuffer;
				std::shared_ptr<MasterNodeConnectionHandler> h;
				
                if (header == ControlStreamHeaderMagic) {
                    h = std::make_shared<MasterNode>(shared_from_this());
                } else if (header == VersionDownloadRequestMagic) {
                    MSCThrow(NotImplementedException());
				} else if (header == DataStreamMagic) {
					h = std::make_shared<MasterNodeClientStream>(shared_from_this());
                } else {
                    MSCThrow(InvalidOperationException(
                            str(format("Invalid header magic 0x%08x received.") % header)));
                }

                assert(h != nullptr);
				handler = h;

				h->service();

            } catch (...) {
				performShutdownByError(boost::current_exception_diagnostic_information());
            }
        });

    }
Example #6
0
ScriptPromise Body::json(ScriptState* scriptState)
{
    return readAsync(scriptState, ResponseAsJSON);
}
Example #7
0
ScriptPromise Body::formData(ScriptState* scriptState)
{
    return readAsync(scriptState, ResponseAsFormData);
}
Example #8
0
ScriptPromise Body::blob(ScriptState* scriptState)
{
    return readAsync(scriptState, ResponseAsBlob);
}
Example #9
0
ScriptPromise Body::arrayBuffer(ScriptState* scriptState)
{
    return readAsync(scriptState, ResponseAsArrayBuffer);
}
Example #10
0
ScriptPromise Body::text(ScriptState* scriptState)
{
    return readAsync(scriptState, ResponseAsText);
}