bool DiscoveryClient::Discover()

in discovery/source/DiscoveryClient.cpp [108:210]
91 lines of code
13 McCabe index (conditional complexity)

        bool DiscoveryClient::Discover(
            const Crt::String &thingName,
            const OnDiscoverResponse &onDiscoverResponse) noexcept
        {
            auto callbackContext = Crt::MakeShared<ClientCallbackContext>(m_allocator);
            if (!callbackContext)
            {
                return false;
            }

            callbackContext->responseCode = 0;

            bool res = m_connectionManager->AcquireConnection(
                [this, callbackContext, thingName, onDiscoverResponse](
                    std::shared_ptr<Crt::Http::HttpClientConnection> connection, int errorCode)
                {
                    if (errorCode)
                    {
                        onDiscoverResponse(nullptr, errorCode, 0);
                        return;
                    }

                    auto request = Aws::Crt::MakeShared<Crt::Http::HttpRequest>(m_allocator, m_allocator);
                    if (request == nullptr)
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                        return;
                    }

                    Crt::StringStream ss;
                    ss << "/greengrass/discover/thing/" << thingName;
                    Crt::String uriStr = ss.str();
                    if (!request->SetMethod(Crt::ByteCursorFromCString("GET")))
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                        return;
                    }

                    if (!request->SetPath(Crt::ByteCursorFromCString(uriStr.c_str())))
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                        return;
                    }

                    Crt::Http::HttpHeader hostNameHeader;
                    hostNameHeader.name = Crt::ByteCursorFromCString("host");
                    hostNameHeader.value = Crt::ByteCursorFromCString(m_hostName.c_str());

                    if (!request->AddHeader(hostNameHeader))
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                        return;
                    }

                    Crt::Http::HttpRequestOptions requestOptions;
                    requestOptions.request = request.get();
                    requestOptions.onIncomingHeaders =
                        [](Crt::Http::HttpStream &, aws_http_header_block, const Crt::Http::HttpHeader *, std::size_t) {
                        };
                    requestOptions.onIncomingHeadersBlockDone =
                        [callbackContext](Crt::Http::HttpStream &stream, aws_http_header_block)
                    { callbackContext->responseCode = stream.GetResponseStatusCode(); };
                    requestOptions.onIncomingBody =
                        [callbackContext](Crt::Http::HttpStream &, const Crt::ByteCursor &data)
                    { callbackContext->ss.write(reinterpret_cast<const char *>(data.ptr), data.len); };
                    requestOptions.onStreamComplete = [request, connection, callbackContext, onDiscoverResponse](
                                                          Crt::Http::HttpStream &, int errorCode)
                    {
                        if (!errorCode && callbackContext->responseCode == 200)
                        {
                            Crt::JsonObject jsonObject(callbackContext->ss.str());
                            DiscoverResponse response(jsonObject.View());
                            onDiscoverResponse(&response, AWS_ERROR_SUCCESS, callbackContext->responseCode);
                        }
                        else
                        {
                            if (!errorCode)
                            {
                                errorCode = AWS_ERROR_UNKNOWN;
                            }
                            onDiscoverResponse(nullptr, errorCode, callbackContext->responseCode);
                        }
                    };

                    auto stream = connection->NewClientStream(requestOptions);
                    if (!stream)
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                    }

                    if (!stream->Activate())
                    {
                        onDiscoverResponse(nullptr, Crt::LastErrorOrUnknown(), 0);
                    }
                });

            if (!res)
            {
                return false;
            }

            return true;
        }