static void importRegistration_proxyFunc()

in bundles/remote_services/remote_service_admin_dfi/src/import_registration_dfi.c [314:384]

• 53 lines of code
• 15 McCabe index (conditional complexity)

static void importRegistration_proxyFunc(void *userData, void *args[], void *returnVal) {
    int  status = CELIX_SUCCESS;
    struct method_entry *entry = userData;
    import_registration_t *import = *((void **)args[0]);

    *(int *) returnVal = CELIX_SUCCESS;

    if (import == NULL || import->send == NULL) {
        status = CELIX_ILLEGAL_ARGUMENT;
    }


    char *invokeRequest = NULL;
    if (status == CELIX_SUCCESS) {
        int rc = jsonRpc_prepareInvokeRequest(entry->dynFunc, entry->id, args, &invokeRequest);
        status = (rc != 0) ? CELIX_BUNDLE_EXCEPTION : CELIX_SUCCESS;
        //printf("Need to send following json '%s'\n", invokeRequest);
    }


    if (status == CELIX_SUCCESS) {
        char *reply = NULL;
        //printf("sending request\n");
        celix_properties_t *metadata = NULL;
        bool cont = remoteInterceptorHandler_invokePreProxyCall(import->interceptorsHandler, import->endpoint->properties,
                                                                dynFunction_getName(entry->dynFunc), &metadata);
        if (cont) {
            status = import->send(import->sendHandle, import->endpoint, invokeRequest, metadata, &reply);
            //printf("request sended. got reply '%s' with status %i\n", reply, rc);

            if (status == CELIX_SUCCESS && dynFunction_hasReturn(entry->dynFunc)) {
                //fjprintf("Handling reply '%s'\n", reply);
                int rsErrno = CELIX_SUCCESS;
                int retVal = jsonRpc_handleReply(entry->dynFunc, reply, args, &rsErrno);
                if(retVal != 0) {
                    status = CELIX_BUNDLE_EXCEPTION;
                } else if (rsErrno != CELIX_SUCCESS) {
                    //return the invocation error of remote service function
                    *(int *) returnVal = rsErrno;
                }
            }

            remoteInterceptorHandler_invokePostProxyCall(import->interceptorsHandler, import->endpoint->properties,
                                                         dynFunction_getName(entry->dynFunc), metadata);
        } else {
            *(int *) returnVal = CELIX_INTERCEPTOR_EXCEPTION;
        }

        //free metadata
        if(metadata != NULL) {
            celix_properties_destroy(metadata);
        }

        if (import->logFile != NULL) {
            static int callCount = 0;
            const char *url = importRegistration_getUrl(import);
            const char *svcName = importRegistration_getServiceName(import);
            fprintf(import->logFile, "REMOTE CALL NR %i\n\turl=%s\n\tservice=%s\n\tpayload=%s\n\treturn_code=%i\n\treply=%s\n",
                                       callCount, url, svcName, invokeRequest, status, reply == NULL ? "null" : reply);
            fflush(import->logFile);
            callCount += 1;
        }
        free(invokeRequest); //Allocated by json_dumps in jsonRpc_prepareInvokeRequest
        free(reply); //Allocated by json_dumps in remoteServiceAdmin_send through curl call
    }

    if (status != CELIX_SUCCESS) {
        //TODO log error
        *(int *) returnVal = status;
    }
}