C++ CDataAccessor::setChannelID方法代码示例

   void testRawArray()
   {
      //setup
      UInt8 data[] = "012";
      CDataAccessor a;
      a.setChannelID(123);
      a.setErrorCode(234);
      a.setOpCode(345);
      a.setData(data, sizeof(data));

      UInt8 array[100];

      a.printContent();

      // test

      UInt32 size = a.getObjectSize();
      a.copyToRawArray(array);

      CPPUNIT_ASSERT_EQUAL(sizeof(data) + 4*4, size);

      CDataAccessor b(array, size);
      b.printContent();
      CPPUNIT_ASSERT_EQUAL(123u, b.getChannelID());
      CPPUNIT_ASSERT_EQUAL(234u, b.getErrorCode());
      CPPUNIT_ASSERT_EQUAL(345u, b.getOpCode());
      CPPUNIT_ASSERT_EQUAL(sizeof(data), b.getDataSize());

      CPPUNIT_ASSERT(0 == memcmp(data, b.getData(), sizeof(data)));
   }

ERROR_CODE CConnectivityAgentProxy::sendData(const UInt32 channel_id, UInt8 const* data,
		const UInt32 size)
{
	LOG4CPLUS_INFO(logger,
			"CConnectivityAgentProxy::sendData() => channel " + convertIntegerToString(channel_id)
					+ ", size " + convertIntegerToString(size));
	ERROR_CODE ret = ERR_FAIL;

	const int MAX_BUF_SIZE = 0xFFFF;

	if ((data != NULL) && ((Int32) size > 0) && (size < MAX_BUF_SIZE))
	{
		mRegistryMutex.lockRead();
		bool found = (mChannelRegistry.find(channel_id) != mChannelRegistry.end());
		mRegistryMutex.unlockRead();

		if (found)
		{
			CDataAccessor requestDA;
			requestDA.setChannelID(channel_id);
			requestDA.setOpCode(E_SEND_DATA);
			requestDA.setData(data, size);
			UInt8 buf[MAX_BUF_SIZE];
			requestDA.copyToRawArray(buf);
			assert(requestDA.getObjectSize() <= MAX_BUF_SIZE);
			if (requestDA.getObjectSize() > MAX_BUF_SIZE)
			{
				LOG4CPLUS_ERROR(logger,
						"CConnectivityAgentProxy::sendData() => ERROR:  \
                     requestDA.getObjectSize() > max buf size");
			}

			UInt32 respSize = 0;
			CError err = mpIpc->request(mMsgIdGen.next(), buf, requestDA.getObjectSize(), NULL,
					respSize);
			if (err.isNoError())
			{
				ret = ERR_OK;
			} else
			{
				LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
			}
		} else

ConnectivityAgentError L1InterfaceStub::receiveData(Buffer & buffer, UInt32 channel_id)
{
    LOG4CPLUS_TRACE(logger, "L1InterfaceStub::receiveData() => channel " +
            convertIntegerToString(channel_id));

    UInt32 offset = 0;
    CDataAccessor accessor;
    ConnectivityAgentError result;
    // TODO ipc errors processing
    // TODO incorrect data processing

    assert(buffer.getFilledSize() <= buffer.getMaxSize());

    LOG4CPLUS_INFO(logger, "L1InterfaceStub::receiveData() =>  buf size "
    + convertIntegerToString(buffer.getFilledSize()));
    if(channel_id == CA_SERVICE_CHANNEL)
    {
        //> If  data received from service channel - process service request
        do
        {

            UInt32 begin = offset;

            UInt16 buf_length = ByteOrder::ntoh16(*reinterpret_cast<UInt16*>
            (buffer.getData() + offset));
            offset += 2;
            LOG4CPLUS_INFO(logger, "L1InterfaceStub::receiveData() =>  buf_length " +
                    convertIntegerToString(buf_length));
            assert(begin + buf_length <= buffer.getFilledSize());
            
            UInt32 operation = ByteOrder::ntoh32(*reinterpret_cast<UInt32*>
                    (buffer.getData() + offset));
            offset += 4;
            accessor.setOpCode(operation);
            
            UInt32 channel_id = ByteOrder::ntoh32(*reinterpret_cast<UInt32*>
                    (buffer.getData() + offset));
            offset += 4;
            accessor.setChannelID(channel_id);
            
            UInt32 data_size = ByteOrder::ntoh32(*reinterpret_cast<UInt32*>
                    (buffer.getData() + offset));
            offset += 4;
            
            UInt32 error_code = ByteOrder::ntoh32(*reinterpret_cast<UInt32*>
                    (buffer.getData() + offset));
            offset += 4;
            accessor.setErrorCode(error_code);

            accessor.setData(buffer.getData() + offset, data_size);
            offset += data_size;
            
            accessor.printContent();
            ///>Process service request
            tServiceCallbacksMap::iterator iter =
                    mServiceCallbacksMap.find(static_cast<tOpCode>(operation));

            if (iter !=mServiceCallbacksMap.end())
            {
                ///> This funny language structure is just callback invocation.
                ///> Not obvious, huh? =)
                (this->*iter->second)(accessor);
                result.setNoError();
            }
            else
            {
                LOG4CPLUS_WARN(logger, "L1InterfaceStub::receiveData() => "
                        "UNKNOWN SERVICE REQUEST = "
                        + convertIntegerToString(operation) + "!!!");
            }

        } while (offset < buffer.getFilledSize());

        LOG4CPLUS_INFO(logger, "L1InterfaceStub::receiveData() => offset "
                + convertIntegerToString(offset) + "!!!");
        assert(buffer.getFilledSize() == offset);
    }
    else
    {
        //> Or pack to accessor and send to client
        accessor.setOpCode(E_RECEIVE_DATA_NTF);
        accessor.setChannelID(channel_id);
        assert (buffer.getFilledSize() > 0);
        accessor.setData(buffer.getData(),buffer.getFilledSize());
        accessor.printContent();
        UInt8* buf = new UInt8[accessor.getObjectSize()];
        accessor.copyToRawArray(buf);

        BaseError ipcError = mpIpc->asyncRequest(mMsgIdGen.next(),
        buf, accessor.getObjectSize(), &mL1ChannelRegistry[channel_id].mClientDir); // TODO use find, and not []

        delete [] buf;
        if (ipcError.isNoError())
        {
            result.setNoError();
        }
        else
        {
            result.setErrorCode(ConnectivityAgentError::ERROR_REQUEST_FAILED);
        }
//.........这里部分代码省略.........

void L1InterfaceStub::RequestTimeout::onTimeout()
{
    CDataAccessor resp;
    UInt32 data = ERR_TIMEOUT;
    if (mEnabled)
    {
        switch (mRequest)
        {
        case E_ALLOCATE_CHANNEL:
        {
            mpOwner->mRegistryMutex.lock();
            bool found = (mpOwner->mL1ChannelRegistry.find(mChannelID) !=
                    mpOwner->mL1ChannelRegistry.end());
            mpOwner->mRegistryMutex.unlock();

            if (found)
            {
                LOG4CPLUS_INFO(logger, "L1InterfaceStub::RequestTimeout::onTimeout()=> channel "
                        + convertIntegerToString(mChannelID) + " allocated!");
            }
            else
            {
                LOG4CPLUS_WARN(logger, "L1InterfaceStub::RequestTimeout::onTimeout()=> Channel "
                        + convertIntegerToString(mChannelID) + " allocation timeout!");
                resp.setChannelID(mChannelID);
                resp.setOpCode(E_ALLOCATE_CHANNEL_RESP);
                resp.setData(reinterpret_cast<UInt8 *>(&data), sizeof(UInt32));
                resp.setErrorCode(ConnectivityAgentError::ERROR_TIMEOUT);
                mpOwner->mRequestedMapMutex.lock();
                mpOwner->mRequestedMap.erase(mChannelID);
                mpOwner->mRequestedMapMutex.unlock();
                mpOwner->sendRequest(resp);
            }
            
            break;
        }
        case E_DEALLOCATE_CHANNEL:
        {
            iviLink::Ipc::DirectionID client_dir;
            bool found = false;
            mpOwner->mRegistryMutex.lock();
            {
                tChannelsRegistryMap::iterator iter = mpOwner->mL1ChannelRegistry.find(mChannelID);
                found = (iter != mpOwner->mL1ChannelRegistry.end());
                if (found)
                {
                    client_dir = iter->second.mClientDir;
                }
            }
            mpOwner->mRegistryMutex.unlock();

            if (found)
            {
                LOG4CPLUS_INFO(logger, "L1InterfaceStub::RequestTimeout::onTimeout() => "
                        "Channel deallocation timeout!");
                resp.setChannelID(mChannelID);
                resp.setOpCode(E_DEALLOCATE_CHANNEL_RESP);
                resp.setData(reinterpret_cast<UInt8 *>(&data), sizeof(UInt32));
                resp.setErrorCode(ConnectivityAgentError::ERROR_TIMEOUT);
                UInt8* buf = new UInt8[resp.getObjectSize()];
                resp.copyToRawArray(buf);

                BaseError err = mpOwner->mpIpc->asyncRequest(mpOwner->mMsgIdGen.next(),
                        buf, resp.getObjectSize(), &client_dir);
                if (!err.isNoError())
                {
                    LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
                }

                delete [] buf;
            }
            else
            {
                LOG4CPLUS_INFO(logger, "L1InterfaceStub::RequestTimeout::onTimeout() => "
                        "channel Deallocated!");
            }
            break;
        }
        default:
            break;
        }
    }
}

ERROR_CODE CConnectivityAgentProxy::deallocateChannel(UInt32 channel_id)
{
	LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
	LOG4CPLUS_INFO(logger,
			"CConnectivityAgentProxy::deallocateChannel(chID = "
					+ convertIntegerToString(channel_id) + ")");
	ERROR_CODE ret = ERR_NOTFOUND;

	mRegistryMutex.lockWrite();
	// Channel info will be saved in info and removed from registry here.
	// In case of some errors, it will be restored in registry.
	tChannelInfo info;
	tChannelsRegistryMap::iterator iter = mChannelRegistry.find(channel_id);
	if (iter == mChannelRegistry.end())
	{
		LOG4CPLUS_ERROR(logger,
				"CConnectivityAgentProxy::deallocateChannel(chID = "
						+ convertIntegerToString(channel_id) + ") => ERROR: Channel not found! ");
	} else
	{
		ret = ERR_OK;
		info = iter->second;
		iter->second.mChannelBuffer.forgetData();
		mChannelRegistry.erase(iter);
		mChannelOnDeallocSet.insert(channel_id);
	}
	mRegistryMutex.unlockWrite();

	if (ret != ERR_OK)
		return ret;

	CDataAccessor requestDA;
	requestDA.setChannelID(channel_id);
	requestDA.setOpCode(E_DEALLOCATE_CHANNEL);
	UInt8* buf = new UInt8[requestDA.getObjectSize()];
	requestDA.copyToRawArray(buf);

	// response will be sent later as a separate request
	UInt32 respSize = 0;
	CError err = mpIpc->request(mMsgIdGen.next(), buf, requestDA.getObjectSize(), NULL, respSize);
	delete[] buf;

	if (!err.isNoError())
	{
		LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
		ret = ERR_FAIL;
	} else
	{
		CDataAccessor responseDA;

		mDeallocateRequestResultCond.lock();
		{
			LOG4CPLUS_INFO(logger,
					"CConnectivityAgentProxy::deallocateChannel waiting for mLastRequestResultDA");
			while (mDeallocateRequestResultMap.find(channel_id) == mDeallocateRequestResultMap.end())
			{
				LOG4CPLUS_INFO(logger, "before wait");
				mDeallocateRequestResultCond.wait();
				LOG4CPLUS_INFO(logger, "after wait");
			}

			responseDA = mDeallocateRequestResultMap[channel_id];
			mDeallocateRequestResultMap.erase(channel_id);
		}
		mDeallocateRequestResultCond.unlock();

		if (responseDA.getData())
		{
			if ((E_DEALLOCATE_CHANNEL_RESP == responseDA.getOpCode())
					&& (channel_id == responseDA.getChannelID()))
			{
				UInt32 data = 0;
				memcpy(&data, responseDA.getData(), sizeof(UInt32));
				responseDA.resetAll();
				ret = static_cast<ERROR_CODE>(data);
			} else
			{
				LOG4CPLUS_ERROR(logger,
						"CConnectivityAgentProxy::deallocateChannel() => ERROR: wrong response type("
								+ convertIntegerToString(responseDA.getOpCode())
								+ ") from Agent  !!! ");
				ret = ERR_WRONG_SEQUENCE;
			}
		} else
		{
			LOG4CPLUS_INFO(logger, "CConnectivityAgentProxy::deallocateChannel() => "
					"channel already deleted form other side");
			ret = ERR_OK;
		}

	}

	if (ret != ERR_OK)
	{
		// something gone wrong, we need to restore information in registry
		mRegistryMutex.lockWrite();

		if (mChannelRegistry.find(channel_id) != mChannelRegistry.end())
		{
			LOG4CPLUS_WARN(logger, "CConnectivityAgentProxy::deallocateChannel: "
//.........这里部分代码省略.........

ERROR_CODE CConnectivityAgentProxy::allocateChannel(TChannelPriority prio, UInt32 channel_id,
		IChannelObserver* observer)
{
	LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
	LOG4CPLUS_INFO(logger,
			"CConnectivityAgentProxy::allocateChannel(type = " + convertIntegerToString((int) prio)
					+ ", id = " + convertIntegerToString(channel_id) + " ), this = "
					+ convertIntegerToString((intptr_t) this));

	ERROR_CODE ret = ERR_FAIL;
	if ((channel_id > 0) && (channel_id <= 0xFFFF) && (NULL != observer))
	{
		mRegistryMutex.lockWrite();
		bool channel_unknown = mChannelRegistry.find(channel_id) == mChannelRegistry.end();
		mRegistryMutex.unlockWrite();

		if (channel_unknown)
		{
			mAllocateRequestCond.lock();
			bool channel_requested = mAllocateRequestMap.find(channel_id)
					!= mAllocateRequestMap.end();
			if (channel_requested)
			{
				ret = ERR_IN_PROGRESS;
				channel_unknown = false;
				LOG4CPLUS_WARN(logger,
						"CConnectivityAgentProxy::allocateChannel() => ERROR: channel allocation in progress!");
			} else
			{
				LOG4CPLUS_INFO(logger,
						"CConnectivityAgentProxy::allocateChannel() => insert request");
				mAllocateRequestMap.insert(
						std::make_pair(channel_id,
								AllocateRequestInfo(prio, observer, false, ERR_UNKNOWN)));
			}
			mAllocateRequestCond.unlock();
		}

		if (channel_unknown)
		{
			CDataAccessor requestDA;
			requestDA.setChannelID(channel_id);
			requestDA.setOpCode(E_ALLOCATE_CHANNEL);
			UInt32 data = prio;
			requestDA.setData(reinterpret_cast<UInt8 *>(&data), sizeof(UInt32));
			UInt8* buf = new UInt8[requestDA.getObjectSize()];
			requestDA.copyToRawArray(buf);

			UInt8 respBuf[100];
			UInt32 respSize = sizeof(respBuf);
			CError err = mpIpc->request(mMsgIdGen.next(), buf, requestDA.getObjectSize(), respBuf,
					respSize);
			delete[] buf;

			if (!err.isNoError())
			{
				LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
				ret = ERR_FAIL;

				mAllocateRequestCond.lock();
				mAllocateRequestMap.erase(channel_id);
				mAllocateRequestCond.unlock();

				LOG4CPLUS_WARN(logger,
						"CConnectivityAgentProxy::allocateChannel() => ERROR: failed to send request");
			} else
			{
				CDataAccessor responseDA;

				if (respSize > 0)
				{
					responseDA = CDataAccessor(respBuf, respSize);
					ret = static_cast<ERROR_CODE>(responseDA.getErrorCode());

					mAllocateRequestCond.lock();
					mAllocateRequestMap.erase(channel_id);
					mAllocateRequestCond.unlock();

					LOG4CPLUS_WARN(logger,
							"CConnectivityAgentProxy::allocateChannel() => ERROR: got error response");
				} else
				{
					mAllocateRequestCond.lock();
					while (true)
					{
						tAllocateRequestMap::iterator it = mAllocateRequestMap.find(channel_id);
						if (it == mAllocateRequestMap.end())
						{
							ret = ERR_FAIL;
							LOG4CPLUS_WARN(logger,
									"CConnectivityAgentProxy::allocateChannel() => ERROR: request was removed");
							break;
						}

						AllocateRequestInfo & info = it->second;
						if (info.mRequestDone)
						{
							LOG4CPLUS_INFO(logger,
									"CConnectivityAgentProxy::allocateChannel() => request done");
							ret = info.mResult;
//.........这里部分代码省略.........