STATUS Peer::initSignaling()

in canary/webrtc-c/src/Peer.cpp [63:176]
91 lines of code
12 McCabe index (conditional complexity)

STATUS Peer::initSignaling(const Canary::PConfig pConfig)
{
    STATUS retStatus = STATUS_SUCCESS;

    ChannelInfo channelInfo;
    SignalingClientCallbacks clientCallbacks;
    CHAR controlPlaneUrl[MAX_CONTROL_PLANE_URI_CHAR_LEN];

    MEMSET(&this->clientInfo, 0, SIZEOF(this->clientInfo));
    MEMSET(&channelInfo, 0, SIZEOF(channelInfo));
    MEMSET(&clientCallbacks, 0, SIZEOF(clientCallbacks));

    this->clientInfo.version = SIGNALING_CLIENT_INFO_CURRENT_VERSION;
    this->clientInfo.loggingLevel = pConfig->logLevel.value;
    STRCPY(this->clientInfo.clientId, pConfig->clientId.value.c_str());

    channelInfo.version = CHANNEL_INFO_CURRENT_VERSION;
    if (!pConfig->endpoint.value.empty()) {
        SNPRINTF(controlPlaneUrl, MAX_CONTROL_PLANE_URI_CHAR_LEN, "%s%s", CONTROL_PLANE_URI_PREFIX, pConfig->endpoint.value.c_str());
        channelInfo.pControlPlaneUrl = (PCHAR) controlPlaneUrl;
    }
    channelInfo.pChannelName = (PCHAR) pConfig->channelName.value.c_str();
    channelInfo.pRegion = (PCHAR) pConfig->region.value.c_str();
    channelInfo.pKmsKeyId = NULL;
    channelInfo.tagCount = 0;
    channelInfo.pTags = NULL;
    channelInfo.channelType = SIGNALING_CHANNEL_TYPE_SINGLE_MASTER;
    channelInfo.channelRoleType = pConfig->isMaster.value ? SIGNALING_CHANNEL_ROLE_TYPE_MASTER : SIGNALING_CHANNEL_ROLE_TYPE_VIEWER;
    channelInfo.cachingPolicy = SIGNALING_API_CALL_CACHE_TYPE_FILE;
    channelInfo.cachingPeriod = SIGNALING_API_CALL_CACHE_TTL_SENTINEL_VALUE;
    channelInfo.asyncIceServerConfig = TRUE;
    channelInfo.retry = TRUE;
    channelInfo.reconnect = TRUE;
    channelInfo.pCertPath = (PCHAR) DEFAULT_KVS_CACERT_PATH;
    channelInfo.messageTtl = 0; // Default is 60 seconds

    this->clientInfo.signalingClientCreationMaxRetryAttempts = MAX_CALL_RETRY_COUNT;

    clientCallbacks.customData = (UINT64) this;
    clientCallbacks.stateChangeFn = [](UINT64 customData, SIGNALING_CLIENT_STATE state) -> STATUS {
        STATUS retStatus = STATUS_SUCCESS;
        PPeer pPeer = (PPeer) customData;
        PCHAR pStateStr;

        signalingClientGetStateString(state, &pStateStr);
        DLOGD("Signaling client state changed to %d - '%s'", state, pStateStr);

        switch (state) {
            case SIGNALING_CLIENT_STATE_NEW:
                pPeer->signalingStartTime = GETTIME();
                break;
            case SIGNALING_CLIENT_STATE_CONNECTED: {
                if (!pPeer->initializedSignaling) {
                    auto duration = (GETTIME() - pPeer->signalingStartTime) / HUNDREDS_OF_NANOS_IN_A_MILLISECOND;
                    DLOGI("Signaling took %lu ms to connect", duration);
                    Canary::Cloudwatch::getInstance().monitoring.pushSignalingInitDelay(duration, Aws::CloudWatch::Model::StandardUnit::Milliseconds);
                    pPeer->initializedSignaling = TRUE;
                }
                break;
            }
            default:
                break;
        }

        // Return success to continue
        return retStatus;
    };
    clientCallbacks.errorReportFn = [](UINT64 customData, STATUS status, PCHAR msg, UINT32 msgLen) -> STATUS {
        PPeer pPeer = (PPeer) customData;
        DLOGW("Signaling client generated an error 0x%08x - '%.*s'", status, msgLen, msg);

        // When an error happens with signaling, we'll let it crash so that this canary can be restarted.
        // The error will be captured in at higher level metrics.
        if (status == STATUS_SIGNALING_ICE_CONFIG_REFRESH_FAILED || status == STATUS_SIGNALING_RECONNECT_FAILED) {
            pPeer->status = status;

            // Let the higher level to terminate
            if (pPeer->callbacks.onDisconnected != NULL) {
                pPeer->callbacks.onDisconnected();
            }
        }

        return STATUS_SUCCESS;
    };
    clientCallbacks.messageReceivedFn = [](UINT64 customData, PReceivedSignalingMessage pMsg) -> STATUS {
        STATUS retStatus = STATUS_SUCCESS;
        PPeer pPeer = (PPeer) customData;
        std::lock_guard<std::recursive_mutex> lock(pPeer->mutex);

        if (!pPeer->foundPeerId.load()) {
            pPeer->peerId = pMsg->signalingMessage.peerClientId;
            DLOGI("Found peer id: %s", pPeer->peerId.c_str());
            pPeer->foundPeerId = TRUE;
            CHK_STATUS(pPeer->initPeerConnection());
        }

        if (pPeer->isMaster && STRCMP(pPeer->peerId.c_str(), pMsg->signalingMessage.peerClientId) != 0) {
            DLOGW("Unexpected receiving message from extra peer: %s", pMsg->signalingMessage.peerClientId);
            CHK(FALSE, retStatus);
        }

        CHK_STATUS(pPeer->handleSignalingMsg(pMsg));

    CleanUp:

        return retStatus;
    };
    CHK_STATUS(createSignalingClientSync(&this->clientInfo, &channelInfo, &clientCallbacks, pAwsCredentialProvider, &signalingClientHandle));
    CHK_STATUS(signalingClientFetchSync(signalingClientHandle));

CleanUp:

    return retStatus;
}