iceoryx源码阅读（八）——IPC通信机制

0 导引

本系列文章对iceoryx源码进行解读，索引如下：

• iceoryx源码阅读（三）——共享内存管理

• iceoryx源码阅读（四）——共享内存通信

• iceoryx源码阅读（五）——共享内存通信

• iceoryx源码阅读（六）——共享内存创建

• iceoryx源码阅读（七）——服务发现机制

1 整体结构

通过前面的介绍，订阅者、发布者与Roudi守护进程之间也需要通信，如上文介绍的，请求Roudi守护进村创建并配置端口数据。整体结构如下图所示：

由于通信层在类Unix操作系统和Windows操作系统下实现不同（见下面的代码片段），所以我们分开介绍其实现。

#if defined(_WIN32)
using IoxIpcChannelType = iox::posix::NamedPipe;
#else
using IoxIpcChannelType = iox::posix::UnixDomainSocket;
#endif

接下来我们从数据的序列化和反序列化开始。

2 序列化与反序列化

前一篇文章中，这部分通信没有使用三方框架，使用简单的字符串拼接的方式进行序列化，如下所示：

template <typename T>
void IpcMessage::addEntry(const T& entry) noexcept
{
    std::stringstream newEntry;
    newEntry << entry;

    if (!isValidEntry(newEntry.str()))
    {
        LogError() << "\'" << newEntry.str().c_str() << "\' is an invalid IPC channel entry";
        m_isValid = false;
    }
    else
    {
        m_msg.append(newEntry.str() + m_separator);
        ++m_numberOfElements;
    }
}

template <typename T>
IpcMessage& IpcMessage::operator<<(const T& entry) noexcept
{
    addEntry(entry);
    return *this;
}

上面的代码较为简单，这里不作详细解释了。反序列化也很简单，这里就贴一下代码了，非常简单粗暴的实现：

std::string IpcMessage::getElementAtIndex(const uint32_t index) const noexcept
{
    std::string messageRemainder(m_msg);
    size_t startPos = 0u;
    size_t endPos = messageRemainder.find_first_of(m_separator, startPos);

    for (uint32_t counter = 0u; endPos != std::string::npos; ++counter)
    {
        if (counter == index)
        {
            return messageRemainder.substr(startPos, endPos - startPos);
        }

        startPos = endPos + 1u;
        endPos = messageRemainder.find_first_of(m_separator, startPos);
    }

    return std::string();
}

3 类Unix系统的实现

正如在 中介绍的，类Unix系统使用Unix域套接字实现IPC通信机制。由UnixDomainSocket封装初始化、销毁、发送和接收等逻辑，这里我们主要介绍发送和接收逻辑的具体实现。

3.1 发送函数send

职责：
封装客户端的消息发送逻辑

参数：

• msg：待发送的消息。

cxx::expected<IpcChannelError> UnixDomainSocket::send(const std::string& msg) const noexcept
{
    // we also support timedSend. The setsockopt call sets the timeout for all further sendto calls, so we must set
    // it to 0 to turn the timeout off
    return timedSend(msg, units::Duration::fromSeconds(0ULL));
}

发送函数send只是简单地调用地超时时间的发送函数timedSend。输入的超时时间为0，意味着立即发送。timedSend的实现如下所示：

cxx::expected<IpcChannelError> UnixDomainSocket::timedSend(const std::string& msg,
                                                           const units::Duration& timeout) const noexcept
{
    if (msg.size() > m_maxMessageSize)
    {
        return cxx::error<IpcChannelError>(IpcChannelError::MESSAGE_TOO_LONG);
    }

    if (IpcChannelSide::SERVER == m_channelSide)
    {
        std::cerr << "sending on server side not supported for unix domain socket \"" << m_name << "\"" << std::endl;
        return cxx::error<IpcChannelError>(IpcChannelError::INTERNAL_LOGIC_ERROR);
    }

    auto tv = timeout.timeval();
    auto setsockoptCall = posixCall(iox_setsockopt)(m_sockfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv))
                              .failureReturnValue(ERROR_CODE)
                              .ignoreErrnos(EWOULDBLOCK)
                              .evaluate();

    if (setsockoptCall.has_error())
    {
        return cxx::error<IpcChannelError>(convertErrnoToIpcChannelError(setsockoptCall.get_error().errnum));
    }
    auto sendCall = posixCall(iox_sendto)(m_sockfd, msg.c_str(), msg.size() + NULL_TERMINATOR_SIZE, 0, nullptr, 0)
                        .failureReturnValue(ERROR_CODE)
                        .evaluate();

    if (sendCall.has_error())
    {
        return cxx::error<IpcChannelError>(convertErrnoToIpcChannelError(sendCall.get_error().errnum));
    }
    return cxx::success<void>();
}

逐段代码分析：

• LINE 04 ～ LINE 13： 错误处理——消息长度过长、类型服务端。整体结构图中，黄色的

• LINE 15 ～ LINE 24： 调用POSIX接口（类Unix系统调用）setsockopt，设置超时时间。

• LINE 25 ～ LINE 32： 调用POSIX接口（类Unix系统调用）sendto发送数据。

可以看到，Unix版本的发送实现就是简单地调用系统调用。

3.2 接收函数receive

职责：
封装消息接收逻辑。

返回：
消息字符串或错误类型。

cxx::expected<std::string, IpcChannelError> UnixDomainSocket::receive() const noexcept
{
    // we also support timedReceive. The setsockopt call sets the timeout for all further recvfrom calls, so we must set
    // it to 0 to turn the timeout off
    struct timeval tv = {};
    tv.tv_sec = 0;
    tv.tv_usec = 0;

    return timedReceive(units::Duration(tv));
}

接收函数receive只是简单地调用地超时时间的发送函数timedReceive。输入的超时时间为0，即没有结果立即返回。timedReceive的实现如下所示：

cxx::expected<std::string, IpcChannelError>
UnixDomainSocket::timedReceive(const units::Duration& timeout) const noexcept
{
    if (IpcChannelSide::CLIENT == m_channelSide)
    {
        std::cerr << "receiving on client side not supported for unix domain socket \"" << m_name << "\"" << std::endl;
        return cxx::error<IpcChannelError>(IpcChannelError::INTERNAL_LOGIC_ERROR);
    }

    auto tv = timeout.timeval();
    auto setsockoptCall = posixCall(iox_setsockopt)(m_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))
                              .failureReturnValue(ERROR_CODE)
                              .ignoreErrnos(EWOULDBLOCK)
                              .evaluate();

    if (setsockoptCall.has_error())
    {
        return cxx::error<IpcChannelError>(convertErrnoToIpcChannelError(setsockoptCall.get_error().errnum));
    }
    // NOLINTJUSTIFICATION needed for recvfrom
    // NOLINTNEXTLINE(hicpp-avoid-c-arrays, cppcoreguidelines-avoid-c-arrays)
    char message[MAX_MESSAGE_SIZE + 1];

    auto recvCall = posixCall(iox_recvfrom)(m_sockfd, &message[0], MAX_MESSAGE_SIZE, 0, nullptr, nullptr)
                        .failureReturnValue(ERROR_CODE)
                        .suppressErrorMessagesForErrnos(EAGAIN, EWOULDBLOCK)
                        .evaluate();
    message[MAX_MESSAGE_SIZE] = 0;

    if (recvCall.has_error())
    {
        return cxx::error<IpcChannelError>(convertErrnoToIpcChannelError(recvCall.get_error().errnum));
    }
    return cxx::success<std::string>(&message[0]);
}

逐段代码分析：

• LINE 04 ～ LINE 08： 错误处理——通道类型服务端。整体结构图中，黄色的。

• LINE 10 ～ LINE 19： 调用POSIX接口（类Unix系统调用）setsockopt，设置超时时间。

• LINE 22 ～ LINE 33： 调用POSIX接口（类Unix系统调用）recvfrom接收数据。

4 Windows系统的实现

由于Windows不支持Unix域套接字，使用共享内存的方式来模拟。每引入一个发布者或订阅者，都需要开辟两条通道——收和发，每条通道会使用单独一块共享内存，即需要开辟两块共享内存。

4.1 发送函数send

职责：
封装消息发送逻辑。

参数：

• msg：待发送的消息。

cxx::expected<IpcChannelError> NamedPipe::send(const std::string& message) const noexcept
{
    if (!m_isInitialized)
    {
        return cxx::error<IpcChannelError>(IpcChannelError::NOT_INITIALIZED);
    }

    if (message.size() > MAX_MESSAGE_SIZE)
    {
        return cxx::error<IpcChannelError>(IpcChannelError::MESSAGE_TOO_LONG);
    }

    cxx::Expects(!m_data->sendSemaphore().wait().has_error());
    IOX_DISCARD_RESULT(m_data->messages.push(Message_t(cxx::TruncateToCapacity, message)));
    cxx::Expects(!m_data->receiveSemaphore().post().has_error());

    return cxx::success<>();
}

逐段代码分析：

• LINE 03 ~ LINE 11： 错误处理——未初始化（消息队列共享内存未创建）、消息长度过长。这里没有判断是服务端还是客户端，估计是不同人实现的。

• LINE 13 ～ LINE 15： 第14行，往消息队列（共享内存）中存入消息。第13行是通过发送信号量判断消息队列是否已满，若已满，则一直等待，直到接收端读取消息，唤醒发送端。第15行是唤醒接收端读取消息。

iceoryx还提供了timedSend函数，带有超时机制，即超时则发送失败。还提供了不等待的版本trySend，若队列已满，则发送失败。这两个函数本文不做介绍。

4.2 接收函数receive

职责：
封装消息接收逻辑。

返回：
消息字符串或错误类型。

cxx::expected<std::string, IpcChannelError> NamedPipe::receive() const noexcept
{
    if (!m_isInitialized)
    {
        return cxx::error<IpcChannelError>(IpcChannelError::NOT_INITIALIZED);
    }

    cxx::Expects(!m_data->receiveSemaphore().wait().has_error());
    auto message = m_data->messages.pop();
    if (message.has_value())
    {
        cxx::Expects(!m_data->sendSemaphore().post().has_error());
        return cxx::success<std::string>(message->c_str());
    }
    return cxx::error<IpcChannelError>(IpcChannelError::INTERNAL_LOGIC_ERROR);
}

逐段代码分析：

• LINE 03 ~ LINE 06： 错误处理——未初始化（消息队列共享内存未创建）。这里没有判断是服务端还是客户端，估计是不同人实现的。

• LINE 08 ～ LINE 14： 第14行，往消息队列（共享内存）中存入消息。第8行是通过接收信号量判断消息队列是否为空，若为空，则一直等待，直到发送端发送消息，唤醒发送端。第12行是唤醒发送端发送消息。

iceoryx还提供了timedReceive函数，带有超时机制，即超时则接收失败。还提供了不等待的版本tryReceive，若队列为空，则接收失败。这两个函数本文不做介绍。

5 Roudi的监听逻辑

Roudi启动后，会开启一个线程来监听和处理来自客户端（订阅者、发布者）的请求，如下所示：

void RouDi::startProcessRuntimeMessagesThread() noexcept
{
    m_handleRuntimeMessageThread = std::thread(&RouDi::processRuntimeMessages, this);
    posix::setThreadName(m_handleRuntimeMessageThread.native_handle(), "IPC-msg-process");
}

线程执行函数为processRuntimeMessages，内部就是一个循环，如下所示：

void RouDi::processRuntimeMessages() noexcept
{
    runtime::IpcInterfaceCreator roudiIpcInterface{IPC_CHANNEL_ROUDI_NAME};

    // the logger is intentionally not used, to ensure that this message is always printed
    std::cout << "RouDi is ready for clients" << std::endl;

    while (m_runHandleRuntimeMessageThread)
    {
        // read RouDi's IPC channel
        runtime::IpcMessage message;
        if (roudiIpcInterface.timedReceive(m_runtimeMessagesThreadTimeout, message))
        {
            auto cmd = runtime::stringToIpcMessageType(message.getElementAtIndex(0).c_str());
            std::string runtimeName = message.getElementAtIndex(1);

            processMessage(message, cmd, RuntimeName_t(cxx::TruncateToCapacity, runtimeName));
        }
    }
}

通过上述代码可知，发送给Roudi的所有消息，第一项为请求类型，第二项为运行。这里调用了processMessage函数，这和上一篇文章中的 关联了。