processRpc()

fl::json fl::Remote::processRpc

(

const fl::json &

request

)

Process JSON-RPC request (with optional "timestamp" field for scheduling) Returns JSON-RPC response: {"result": ...} or {"error": {...}}.

Definition at line 134 of file remote.cpp.hpp.

                                               {
    // Extract optional timestamp field (0 = immediate, >0 = scheduled)
    u32 timestamp = 0;
    if (request.contains("timestamp") && request["timestamp"].is_int()) {
        timestamp = static_cast<u32>(request["timestamp"].as_int().value());
    }
 
    u32 receivedAt = fl::millis();
 
    // Execute or schedule
    if (timestamp == 0) {
        // Store request ID BEFORE invoking function (needed for async functions)
        // This allows sendAsyncResponse() to find the request ID while function is running
        if (request.contains("id") && request.contains("method")) {
            fl::string methodName = request["method"].as_string().value_or("");
            int requestId = request["id"].as_int().value_or(0);
            mAsyncRequests[methodName] = {requestId, receivedAt};
            FL_DBG("Stored request ID for " << methodName.c_str() << " (id=" << requestId << ")");
        }
 
        // Immediate execution - pass directly to Rpc
        fl::json response = mRpc.handle(request);
 
        // For async functions, response already sent via sendAsyncResponse()
        if (response.contains("__async") && response["__async"].as_bool().value_or(false)) {
            // Don't return response (ACK already sent by Rpc)
            // Return null to prevent Server from queuing it
            fl::json nullResponse = fl::json::object();
            nullResponse.set("__skip", true);  // Marker to skip queueing
            return nullResponse;
        }
 
        // For sync functions, remove request ID (not needed)
        if (request.contains("method")) {
            fl::string methodName = request["method"].as_string().value_or("");
            mAsyncRequests.erase(methodName);
        }
 
        // Record result if successful
        if (response.contains("result") && request.contains("method")) {
            fl::string funcName = request["method"].as_string().value_or("");
            recordResult(funcName, response["result"], 0, receivedAt, receivedAt, false);
        }
 
        return response;
    } else {
        // Scheduled execution - result will be pushed to ResponseSink after execution
        scheduleFunction(timestamp, receivedAt, request);
        FL_DBG("RPC: Scheduled function - result will be pushed after execution");
 
        // Return acknowledgment with null result and "scheduled" marker
        fl::json response = fl::json::object();
        if (request.contains("id")) {
            response.set("id", request["id"]);
        }
        response.set("result", fl::json(nullptr));
        response.set("scheduled", true);  // Marker to not queue this response
        return response;
    }
}

References fl::json::as_int(), fl::json::as_string(), fl::basic_string::c_str(), fl::json::contains(), FL_DBG, fl::json::is_int(), mAsyncRequests, fl::millis(), mRpc, fl::json::object(), recordResult(), requestId, scheduleFunction(), fl::json::set(), and fl::type_rank< T >::value.

Referenced by Remote().

Here is the call graph for this function:

Here is the caller graph for this function: