# git clone https://github.com/apache/thrift.git
# cd thrift
# ./bootstrap.sh
# ./configure
# make
# make install

namespace cl shared


struct Param {
  1: string key
  2: i32 value
}

struct Result {
  1: bool result
}

service RequestService {
  Result sendMessage(1: Param param)
}

#include <glib-object.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>

#include <thrift/c_glib/thrift.h>
#include <thrift/c_glib/protocol/thrift_binary_protocol_factory.h>
#include <thrift/c_glib/protocol/thrift_protocol_factory.h>
#include <thrift/c_glib/server/thrift_server.h>
#include <thrift/c_glib/server/thrift_simple_server.h>
#include <thrift/c_glib/transport/thrift_buffered_transport_factory.h>
#include <thrift/c_glib/transport/thrift_server_socket.h>
#include <thrift/c_glib/transport/thrift_server_transport.h>

#include "gen-c_glib/request_service.h"




ThriftServer *server = NULL;
gboolean sigint_received = FALSE;

/* Handle SIGINT ("Ctrl-C") signals by gracefully stopping the
   server */
static void
sigint_handler(int signal_number) {
    THRIFT_UNUSED_VAR (signal_number);

    /* Take note we were called */
    sigint_received = TRUE;

    /* Shut down the server gracefully */
    if (server != NULL)
        thrift_server_stop(server);
}

int main(void) {
    RequestServiceHandler *handler;
    RequestServiceProcessor *processor;
    ThriftServerTransport *server_transport;
    ThriftTransportFactory *transport_factory;
    ThriftProtocolFactory *protocol_factory;

    struct sigaction sigint_action;

    GError *error = NULL;
    int exit_status = 0;

    handler = g_object_new(TYPE_REQUEST_SERVICE_HANDLER, NULL);
    processor = g_object_new(TYPE_REQUEST_SERVICE_PROCESSOR, "handler", handler, NULL);
    server_transport = g_object_new(THRIFT_TYPE_SERVER_SOCKET, "port", 9090, NULL);
    transport_factory = g_object_new(THRIFT_TYPE_BUFFERED_TRANSPORT_FACTORY, NULL);
    protocol_factory = g_object_new(THRIFT_TYPE_BINARY_PROTOCOL_FACTORY, NULL);
    server = g_object_new(THRIFT_TYPE_SIMPLE_SERVER,
                          "processor", processor,
                          "server_transport", server_transport,
                          "input_transport_factory", transport_factory,
                          "output_transport_factory", transport_factory,
                          "input_protocol_factory", protocol_factory,
                          "output_protocol_factory", protocol_factory,
                          NULL);
    memset(&sigint_action, 0, sizeof(sigint_action));
    sigint_action.sa_handler = sigint_handler;
    sigint_action.sa_flags = SA_RESETHAND;
    sigaction(SIGINT, &sigint_action, NULL);
    printf("Starting the server...\n");
    thrift_server_serve(server, &error);
    printf("server %p error %p\n",server,error);
    if (!sigint_received) {
        g_message ("thrift_server_serve: %s",
                   error != NULL ? error->message : "(null)");
        g_clear_error(&error);
    }

    puts("done.");

    g_object_unref(server);
    g_object_unref(transport_factory);
    g_object_unref(protocol_factory);
    g_object_unref(server_transport);

    g_object_unref(processor);
    g_object_unref(handler);

    return exit_status;
}

/**
 * Autogenerated by Thrift Compiler (0.17.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#include <string.h>
#include <thrift/c_glib/thrift.h>
#include <thrift/c_glib/thrift_application_exception.h>
#include <stdio.h>
#include <stdbool.h>
#include "request_service.h"

gboolean
request_service_if_send_message(RequestServiceIf *iface, Result **_return, const Param *param, GError **error) {
    return REQUEST_SERVICE_IF_GET_INTERFACE (iface)->send_message(iface, _return, param, error);
}

GType
request_service_if_get_type(void) {
    static GType type = 0;
    if (type == 0) {
        static const GTypeInfo type_info =
                {
                        sizeof(RequestServiceIfInterface),
                        NULL,  /* base_init */
                        NULL,  /* base_finalize */
                        NULL,  /* class_init */
                        NULL,  /* class_finalize */
                        NULL,  /* class_data */
                        0,     /* instance_size */
                        0,     /* n_preallocs */
                        NULL,  /* instance_init */
                        NULL   /* value_table */
                };
        type = g_type_register_static(G_TYPE_INTERFACE,
                                      "RequestServiceIf",
                                      &type_info, 0);
    }
    return type;
}

static void
request_service_if_interface_init(RequestServiceIfInterface *iface);

G_DEFINE_TYPE_WITH_CODE (RequestServiceClient, request_service_client,
                         G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE(TYPE_REQUEST_SERVICE_IF,
                                               request_service_if_interface_init))

enum _RequestServiceClientProperties {
    PROP_0,
    PROP_REQUEST_SERVICE_CLIENT_INPUT_PROTOCOL,
    PROP_REQUEST_SERVICE_CLIENT_OUTPUT_PROTOCOL
};

void
request_service_client_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) {
    RequestServiceClient *client = REQUEST_SERVICE_CLIENT (object);

    THRIFT_UNUSED_VAR (pspec);

    switch (property_id) {
        case PROP_REQUEST_SERVICE_CLIENT_INPUT_PROTOCOL:
            client->input_protocol = g_value_get_object(value);
            break;
        case PROP_REQUEST_SERVICE_CLIENT_OUTPUT_PROTOCOL:
            client->output_protocol = g_value_get_object(value);
            break;
    }
}

void
request_service_client_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
    RequestServiceClient *client = REQUEST_SERVICE_CLIENT (object);

    THRIFT_UNUSED_VAR (pspec);

    switch (property_id) {
        case PROP_REQUEST_SERVICE_CLIENT_INPUT_PROTOCOL:
            g_value_set_object(value, client->input_protocol);
            break;
        case PROP_REQUEST_SERVICE_CLIENT_OUTPUT_PROTOCOL:
            g_value_set_object(value, client->output_protocol);
            break;
    }
}

gboolean request_service_client_send_send_message(RequestServiceIf *iface, const Param *param, GError **error) {
    gint32 cseqid = 0;
    ThriftProtocol *protocol = REQUEST_SERVICE_CLIENT (iface)->output_protocol;

    if (thrift_protocol_write_message_begin(protocol, "sendMessage", T_CALL, cseqid, error) < 0)
        return FALSE;

    {
        gint32 ret;
        gint32 xfer = 0;


        if ((ret = thrift_protocol_write_struct_begin(protocol, "sendMessage_args", error)) < 0)
            return 0;
        xfer += ret;
        if ((ret = thrift_protocol_write_field_begin(protocol, "param", T_STRUCT, 1, error)) < 0)
            return 0;
        xfer += ret;
        if ((ret = thrift_struct_write(THRIFT_STRUCT (param), protocol, error)) < 0)
            return 0;
        xfer += ret;

        if ((ret = thrift_protocol_write_field_end(protocol, error)) < 0)
            return 0;
        xfer += ret;
        if ((ret = thrift_protocol_write_field_stop(protocol, error)) < 0)
            return 0;
        xfer += ret;
        if ((ret = thrift_protocol_write_struct_end(protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_write_message_end(protocol, error) < 0)
        return FALSE;
    if (!thrift_transport_flush(protocol->transport, error))
        return FALSE;
    if (!thrift_transport_write_end(protocol->transport, error))
        return FALSE;

    return TRUE;
}

gboolean request_service_client_recv_send_message(RequestServiceIf *iface, Result **_return, GError **error) {
    gint32 rseqid;
    gchar *fname = NULL;
    ThriftMessageType mtype;
    ThriftProtocol *protocol = REQUEST_SERVICE_CLIENT (iface)->input_protocol;
    ThriftApplicationException *xception;

    if (thrift_protocol_read_message_begin(protocol, &fname, &mtype, &rseqid, error) < 0) {
        if (fname) g_free(fname);
        return FALSE;
    }

    if (mtype == T_EXCEPTION) {
        if (fname) g_free(fname);
        xception = g_object_new(THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
        thrift_struct_read(THRIFT_STRUCT (xception), protocol, NULL);
        thrift_protocol_read_message_end(protocol, NULL);
        thrift_transport_read_end(protocol->transport, NULL);
        g_set_error(error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s",
                    xception->message);
        g_object_unref(xception);
        return FALSE;
    } else if (mtype != T_REPLY) {
        if (fname) g_free(fname);
        thrift_protocol_skip(protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end(protocol, NULL);
        thrift_transport_read_end(protocol->transport, NULL);
        g_set_error(error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE,
                    "invalid message type %d, expected T_REPLY", mtype);
        return FALSE;
    } else if (strncmp(fname, "sendMessage", 11) != 0) {
        thrift_protocol_skip(protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end(protocol, error);
        thrift_transport_read_end(protocol->transport, error);
        g_set_error(error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME,
                    "wrong method name %s, expected sendMessage", fname);
        if (fname) g_free(fname);
        return FALSE;
    }
    if (fname) g_free(fname);

    {
        gint32 ret;
        gint32 xfer = 0;
        gchar *name = NULL;
        ThriftType ftype;
        gint16 fid;
        guint32 len = 0;
        gpointer data = NULL;


        /* satisfy -Wall in case these aren't used */
        THRIFT_UNUSED_VAR (len);
        THRIFT_UNUSED_VAR (data);

        /* read the struct begin marker */
        if ((ret = thrift_protocol_read_struct_begin(protocol, &name, error)) < 0) {
            if (name) g_free(name);
            return 0;
        }
        xfer += ret;
        if (name) g_free(name);
        name = NULL;

        /* read the struct fields */
        while (1) {
            /* read the beginning of a field */
            if ((ret = thrift_protocol_read_field_begin(protocol, &name, &ftype, &fid, error)) < 0) {
                if (name) g_free(name);
                return 0;
            }
            xfer += ret;
            if (name) g_free(name);
            name = NULL;

            /* break if we get a STOP field */
            if (ftype == T_STOP) {
                break;
            }

            switch (fid) {
                case 0:
                    if (ftype == T_STRUCT) {
                        if ((ret = thrift_struct_read(THRIFT_STRUCT (*_return), protocol, error)) < 0) {
                            return 0;
                        }
                        xfer += ret;
                    } else {
                        if ((ret = thrift_protocol_skip(protocol, ftype, error)) < 0)
                            return 0;
                        xfer += ret;
                    }
                    break;
                default:
                    if ((ret = thrift_protocol_skip(protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                    break;
            }
            if ((ret = thrift_protocol_read_field_end(protocol, error)) < 0)
                return 0;
            xfer += ret;
        }

        if ((ret = thrift_protocol_read_struct_end(protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_read_message_end(protocol, error) < 0)
        return FALSE;

    if (!thrift_transport_read_end(protocol->transport, error))
        return FALSE;

    return TRUE;
}

gboolean
request_service_client_send_message(RequestServiceIf *iface, Result **_return, const Param *param, GError **error) {
    if (!request_service_client_send_send_message(iface, param, error))
        return FALSE;
    if (!request_service_client_recv_send_message(iface, _return, error))
        return FALSE;
    return TRUE;
}

static void
request_service_if_interface_init(RequestServiceIfInterface *iface) {
    iface->send_message = request_service_client_send_message;
}

static void
request_service_client_init(RequestServiceClient *client) {
    client->input_protocol = NULL;
    client->output_protocol = NULL;
}

static void
request_service_client_class_init(RequestServiceClientClass *cls) {
    GObjectClass *gobject_class = G_OBJECT_CLASS (cls);
    GParamSpec *param_spec;

    gobject_class->set_property = request_service_client_set_property;
    gobject_class->get_property = request_service_client_get_property;

    param_spec = g_param_spec_object("input_protocol",
                                     "input protocol (construct)",
                                     "Set the client input protocol",
                                     THRIFT_TYPE_PROTOCOL,
                                     G_PARAM_READWRITE);
    g_object_class_install_property(gobject_class,
                                    PROP_REQUEST_SERVICE_CLIENT_INPUT_PROTOCOL, param_spec);

    param_spec = g_param_spec_object("output_protocol",
                                     "output protocol (construct)",
                                     "Set the client output protocol",
                                     THRIFT_TYPE_PROTOCOL,
                                     G_PARAM_READWRITE);
    g_object_class_install_property(gobject_class,
                                    PROP_REQUEST_SERVICE_CLIENT_OUTPUT_PROTOCOL, param_spec);
}

static void
request_service_handler_request_service_if_interface_init(RequestServiceIfInterface *iface);

G_DEFINE_TYPE_WITH_CODE (RequestServiceHandler,
                         request_service_handler,
                         G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE(TYPE_REQUEST_SERVICE_IF,
                                               request_service_handler_request_service_if_interface_init))

gboolean
request_service_handler_send_message(RequestServiceIf *iface, Result **_return, const Param *param, GError **error) {
    g_return_val_if_fail (IS_REQUEST_SERVICE_HANDLER(iface), FALSE);


    printf("%p %p \n", param->key, error);  // 这里写自己server的业务，有点头大。。。

    return REQUEST_SERVICE_HANDLER_GET_CLASS (iface)->send_message(iface, _return, param, error);
}

static void
request_service_handler_request_service_if_interface_init(RequestServiceIfInterface *iface) {
    iface->send_message = request_service_handler_send_message;             //这里自己注册
}

static void
request_service_handler_init(RequestServiceHandler *self) {
    THRIFT_UNUSED_VAR (self);
}

static gboolean
request_service_handler_sends_message(RequestServiceIf *iface, Result **_return, const Param *param, GError **error) {
    THRIFT_UNUSED_VAR (iface);
    THRIFT_UNUSED_VAR (error);
    printf("service request_service_handler_sends_message run  key-> %s, value -> %d \n",param->key,param->value);
    puts("zip()");
    Result *result = g_object_new(TYPE_RESULT, NULL);
    result->result = true;
    *_return = result;
    return TRUE;
}

static void
request_service_handler_class_init(RequestServiceHandlerClass *cls) {
    printf("request_service_handler_class_init in request\n");

    cls->send_message = request_service_handler_sends_message;
}

enum _RequestServiceProcessorProperties {
    PROP_REQUEST_SERVICE_PROCESSOR_0,
    PROP_REQUEST_SERVICE_PROCESSOR_HANDLER
};

G_DEFINE_TYPE (RequestServiceProcessor,
               request_service_processor,
               THRIFT_TYPE_DISPATCH_PROCESSOR)

typedef gboolean (*RequestServiceProcessorProcessFunction)(RequestServiceProcessor *,
                                                           gint32,
                                                           ThriftProtocol *,
                                                           ThriftProtocol *,
                                                           GError **);

typedef struct {
    gchar *name;
    RequestServiceProcessorProcessFunction function;
} request_service_processor_process_function_def;

static gboolean
request_service_processor_process_send_message(RequestServiceProcessor *,
                                               gint32,
                                               ThriftProtocol *,
                                               ThriftProtocol *,
                                               GError **);

static request_service_processor_process_function_def
        request_service_processor_process_function_defs[1] = {
        {
                "sendMessage",
                request_service_processor_process_send_message
        }
};

static gboolean
request_service_processor_process_send_message(RequestServiceProcessor *self,
                                               gint32 sequence_id,
                                               ThriftProtocol *input_protocol,
                                               ThriftProtocol *output_protocol,
                                               GError **error) {
    gboolean result = TRUE;
    ThriftTransport *transport;
    ThriftApplicationException *xception;
    RequestServiceSendMessageArgs *args =
            g_object_new(TYPE_REQUEST_SERVICE_SEND_MESSAGE_ARGS, NULL);

    printf("request_service_processor_process_send_message\n");
    g_object_get(input_protocol, "transport", &transport, NULL);

    if ((thrift_struct_read(THRIFT_STRUCT (args), input_protocol, error) != -1) &&
        (thrift_protocol_read_message_end(input_protocol, error) != -1) &&
        (thrift_transport_read_end(transport, error) != FALSE)) {
        Param *param;
        Result *return_value;
        RequestServiceSendMessageResult *result_struct;

        g_object_get(args,
                     "param", &param,
                     NULL);

        g_object_unref(transport);
        g_object_get(output_protocol, "transport", &transport, NULL);

        result_struct = g_object_new(TYPE_REQUEST_SERVICE_SEND_MESSAGE_RESULT, NULL);
        g_object_get(result_struct, "success", &return_value, NULL);

        if (request_service_handler_send_message(REQUEST_SERVICE_IF (self->handler),
                                                 &return_value,
                                                 param,
                                                 error) == TRUE) {
            g_object_set(result_struct, "success", return_value, NULL);

            result =
                    ((thrift_protocol_write_message_begin(output_protocol,
                                                          "sendMessage",
                                                          T_REPLY,
                                                          sequence_id,
                                                          error) != -1) &&
                     (thrift_struct_write(THRIFT_STRUCT (result_struct),
                                          output_protocol,
                                          error) != -1));
        } else {
            if (*error == NULL)
                g_warning ("RequestService.sendMessage implementation returned FALSE "
                           "but did not set an error");

            xception =
                    g_object_new(THRIFT_TYPE_APPLICATION_EXCEPTION,
                                 "type", *error != NULL ? (*error)->code :
                                         THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,
                                 "message", *error != NULL ? (*error)->message : NULL,
                                 NULL);
            g_clear_error(error);

            result =
                    ((thrift_protocol_write_message_begin(output_protocol,
                                                          "sendMessage",
                                                          T_EXCEPTION,
                                                          sequence_id,
                                                          error) != -1) &&
                     (thrift_struct_write(THRIFT_STRUCT (xception),
                                          output_protocol,
                                          error) != -1));

            g_object_unref(xception);
        }

        if (param != NULL)
            g_object_unref(param);
        if (return_value != NULL)
            g_object_unref(return_value);
        g_object_unref(result_struct);

        if (result == TRUE)
            result =
                    ((thrift_protocol_write_message_end(output_protocol, error) != -1) &&
                     (thrift_transport_write_end(transport, error) != FALSE) &&
                     (thrift_transport_flush(transport, error) != FALSE));
    } else
        result = FALSE;

    g_object_unref(transport);
    g_object_unref(args);

    return result;
}

static gboolean
request_service_processor_dispatch_call(ThriftDispatchProcessor *dispatch_processor,
                                        ThriftProtocol *input_protocol,
                                        ThriftProtocol *output_protocol,
                                        gchar *method_name,
                                        gint32 sequence_id,
                                        GError **error) {
    request_service_processor_process_function_def *process_function_def;
    gboolean dispatch_result = FALSE;

    RequestServiceProcessor *self = REQUEST_SERVICE_PROCESSOR (dispatch_processor);
    ThriftDispatchProcessorClass *parent_class =
            g_type_class_peek_parent(REQUEST_SERVICE_PROCESSOR_GET_CLASS (self));

    process_function_def = g_hash_table_lookup(self->process_map, method_name);
    if (process_function_def != NULL) {
        g_free(method_name);
        dispatch_result = (*process_function_def->function)(self,
                                                            sequence_id,
                                                            input_protocol,
                                                            output_protocol,
                                                            error);
    } else {
        dispatch_result = parent_class->dispatch_call(dispatch_processor,
                                                      input_protocol,
                                                      output_protocol,
                                                      method_name,
                                                      sequence_id,
                                                      error);
    }

    return dispatch_result;
}

static void
request_service_processor_set_property(GObject *object,
                                       guint property_id,
                                       const GValue *value,
                                       GParamSpec *pspec) {
    RequestServiceProcessor *self = REQUEST_SERVICE_PROCESSOR (object);

    switch (property_id) {
        case PROP_REQUEST_SERVICE_PROCESSOR_HANDLER:
            if (self->handler != NULL)
                g_object_unref(self->handler);
            self->handler = g_value_get_object(value);
            g_object_ref (self->handler);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
            break;
    }
}

static void
request_service_processor_get_property(GObject *object,
                                       guint property_id,
                                       GValue *value,
                                       GParamSpec *pspec) {
    RequestServiceProcessor *self = REQUEST_SERVICE_PROCESSOR (object);

    switch (property_id) {
        case PROP_REQUEST_SERVICE_PROCESSOR_HANDLER:
            g_value_set_object(value, self->handler);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
            break;
    }
}

static void
request_service_processor_dispose(GObject *gobject) {
    RequestServiceProcessor *self = REQUEST_SERVICE_PROCESSOR (gobject);

    if (self->handler != NULL) {
        g_object_unref(self->handler);
        self->handler = NULL;
    }

    G_OBJECT_CLASS (request_service_processor_parent_class)->dispose(gobject);
}

static void
request_service_processor_finalize(GObject *gobject) {
    RequestServiceProcessor *self = REQUEST_SERVICE_PROCESSOR (gobject);

    thrift_safe_hash_table_destroy(self->process_map);

    G_OBJECT_CLASS (request_service_processor_parent_class)->finalize(gobject);
}

static void
request_service_processor_init(RequestServiceProcessor *self) {
    guint index;

    self->handler = NULL;
    self->process_map = g_hash_table_new(g_str_hash, g_str_equal);

    for (index = 0; index < 1; index += 1)
        g_hash_table_insert(self->process_map,
                            request_service_processor_process_function_defs[index].name,
                            &request_service_processor_process_function_defs[index]);
}

static void
request_service_processor_class_init(RequestServiceProcessorClass *cls) {
    GObjectClass *gobject_class = G_OBJECT_CLASS (cls);
    ThriftDispatchProcessorClass *dispatch_processor_class =
            THRIFT_DISPATCH_PROCESSOR_CLASS (cls);
    GParamSpec *param_spec;

    gobject_class->dispose = request_service_processor_dispose;
    gobject_class->finalize = request_service_processor_finalize;
    gobject_class->set_property = request_service_processor_set_property;
    gobject_class->get_property = request_service_processor_get_property;

    dispatch_processor_class->dispatch_call = request_service_processor_dispatch_call;
    cls->dispatch_call = request_service_processor_dispatch_call;

    param_spec = g_param_spec_object("handler",
                                     "Service handler implementation",
                                     "The service handler implementation "
                                     "to which method calls are dispatched.",
                                     TYPE_REQUEST_SERVICE_HANDLER,
                                     G_PARAM_READWRITE);
    g_object_class_install_property(gobject_class,
                                    PROP_REQUEST_SERVICE_PROCESSOR_HANDLER,
                                    param_spec);
}

#include <stdio.h>
#include <glib-object.h>

#include <thrift/c_glib/protocol/thrift_binary_protocol.h>
#include <thrift/c_glib/transport/thrift_buffered_transport.h>
#include <thrift/c_glib/transport/thrift_socket.h>

#include "gen-c_glib/request_service.h"

int main() {
    ThriftSocket *socket;
    ThriftTransport *transport;
    ThriftProtocol *protocol;
    RequestServiceIf *client;
    socket = g_object_new(THRIFT_TYPE_SOCKET,
                          "hostname", "localhost",
                          "port", 9090,
                          NULL);
    transport = g_object_new(THRIFT_TYPE_BUFFERED_TRANSPORT,
                             "transport", socket,
                             NULL);
    protocol = g_object_new(THRIFT_TYPE_BINARY_PROTOCOL,
                            "transport", transport,
                            NULL);
    GError *error = NULL;


    thrift_transport_open(transport, &error);
    printf("open client err %p \n", error);
    client = g_object_new(TYPE_REQUEST_SERVICE_CLIENT,
                          "input_protocol", protocol,
                          "output_protocol", protocol,
                          NULL);
    printf("client init finish %p \n", client);
    Result *result = g_object_new(TYPE_RESULT, NULL);
    Param *param = g_object_new(TYPE_PARAM, NULL);
    param->key = "test";
    param->value = 2;
    printf("param %s %d \n", param->key,param->value);
    gboolean ret = request_service_if_send_message(client, &result, param, &error);
    printf("ret %b \n", ret);
    printf("result %d \n", result->result);
    printf("error %s \n", error->message);

}

cmake_minimum_required(VERSION 3.24)
project(thrift_rpc C)

set(CMAKE_C_STANDARD 11)
include_directories(/usr/include/glib-2.0)
include_directories(/usr/lib/x86_64-linux-gnu/glib-2.0/include)
add_executable(thrift_rpc main.c gen-c_glib/request_service.c gen-c_glib/model_types.c)
target_link_libraries(thrift_rpc /usr/local/lib/libthrift_c_glib.so)
target_link_libraries(thrift_rpc /usr/lib/x86_64-linux-gnu/libgobject-2.0.so)
target_link_libraries(thrift_rpc /usr/lib/x86_64-linux-gnu/libglib-2.0.so)



project(thrift_rpc_server C)
set(CMAKE_C_STANDARD 11)

add_executable(thrift_rpc_server server.c gen-c_glib/request_service.c gen-c_glib/model_types.c)

include_directories(/usr/include/glib-2.0)
include_directories(/usr/lib/x86_64-linux-gnu/glib-2.0/include)

target_link_libraries(thrift_rpc_server /usr/local/lib/libthrift_c_glib.so)
target_link_libraries(thrift_rpc_server /usr/lib/x86_64-linux-gnu/libgobject-2.0.so)
target_link_libraries(thrift_rpc_server /usr/lib/x86_64-linux-gnu/libglib-2.0.so)

# wget https://github.com/protocolbuffers/protobuf/releases/download/v22.0/protobuf-22.0.tar.gz
# tar -zxvf protobuf-22.0.tar.gz
# cd protobuf-22.0
# ./autogen.sh
# ./configure
# make 
# make install

# wget https://github.com/protobuf-c/protobuf-c/releases/download/v1.4.1/protobuf-c-1.4.1.tar.gz
# tar -zxvf protobuf-c-1.4.1.tar.gz
# cd protobuf-c
# ./autogen.sh
# ./configure
# make 
# make install

# git clone https://github.com/protobuf-c/protobuf-c-rpc.git
# cd protobuf-c-rpc
# ./autogen.sh
# ./configure
# make 
# make install

syntax = "proto3";

message Param {
  string message = 1;
}
message Result {
  bool result = 1;
}


service RpcSendMsg {
  rpc Send (Param) returns (Result);
}

#include "stdio.h"
#include "model.pb-c.h"
#include <string.h>
#include <protobuf-c-rpc/protobuf-c-rpc.h>
#include <stdbool.h>

static void example__send(RpcSendMsg_Service *service, const Param *param, Result_Closure closure, void *closure_data) {
    printf("example__send  run  message:%s \n",param->message);
    (void) service;
    Result result = RESULT__INIT;
    if (strcmp(param->message, "hello") != 0) {
        result.result = true;
    } else {
        result.result = false;
    }
    closure(&result, closure_data);
}

static RpcSendMsg_Service rpc_send_msg_service = RPC_SEND_MSG__INIT(example__);

int main(void) {
    printf("service start \n");
    ProtobufC_RPC_Server *server;
    ProtobufC_RPC_AddressType address_type = PROTOBUF_C_RPC_ADDRESS_TCP;
    server = protobuf_c_rpc_server_new(address_type, "12345", (ProtobufCService *) &rpc_send_msg_service, NULL);
    printf("service start at 12345 port\n");
    for (;;)
        protobuf_c_rpc_dispatch_run(protobuf_c_rpc_dispatch_default());
}

//
// Created by Eviltuzki on 23-2-11.
//
#include "stdio.h"
#include <string.h>
#include "model.pb-c.h"
#include <protobuf-c-rpc//protobuf-c-rpc.h>


static void
handler_result(const Result *result, void *closure_data) {
    printf("rpc result %d\n", result->result);
}

int main(void) {
    ProtobufCService *service;
    ProtobufC_RPC_Client *client;
    ProtobufC_RPC_AddressType address_type = PROTOBUF_C_RPC_ADDRESS_TCP;
    const char *name = "localhost:12345";
    service = protobuf_c_rpc_client_new(address_type, name, &rpc_send_msg__descriptor, NULL);
    printf("connenct to server service is %p \n",service);
    if (service == NULL) {
        printf("error creating client \n");
        return 0;
    }
    client = (ProtobufC_RPC_Client *) service;
    while (!protobuf_c_rpc_client_is_connected(client))
        protobuf_c_rpc_dispatch_run(protobuf_c_rpc_dispatch_default());
    protobuf_c_boolean is_done = 0;
    Param param = PARAM__INIT;
    param.message = "hello1";
    rpc_send_msg__send(service, &param, handler_result, &is_done);
    while (!is_done)
        protobuf_c_rpc_dispatch_run(protobuf_c_rpc_dispatch_default());
    return 0;
}

cmake_minimum_required(VERSION 3.24)
project(rpc C)

set(CMAKE_C_STANDARD 17)

add_executable(rpc main.c model.pb-c.h model.pb-c.c)
target_link_libraries(rpc /usr/local/lib//libprotobuf-c-rpc.so)
target_link_libraries(rpc /usr/local/lib/libprotobuf-c.so)
target_link_libraries(rpc /usr/local/lib/libprotoc.so)
target_link_libraries(rpc /usr/local/lib/libprotobuf-lite.so)
target_link_libraries(rpc /usr/local/lib/libprotobuf.so)


project(rpc-s C)
add_executable(rpc-s server.c model.pb-c.h model.pb-c.c)
target_link_libraries(rpc-s /usr/local/lib//libprotobuf-c-rpc.so)
target_link_libraries(rpc-s /usr/local/lib/libprotobuf-c.so)
target_link_libraries(rpc-s /usr/local/lib/libprotoc.so)
target_link_libraries(rpc-s /usr/local/lib/libprotobuf-lite.so)
target_link_libraries(rpc-s /usr/local/lib/libprotobuf.so)

$GOPATH/src/github.com/kata-containers/tests/.ci/aarch64/install_rom_aarch64.sh

dnf install -y python python3 python3-distutils-extra uuid-devel bison flex

sudo .ci/aarch64/install_rom_aarch64.sh

$GOPATH/src/github.com/kata-containers/kata-containers/tools/packaging/kernel/patches/5.4.x/0006-arm64-mm-Enable-memory-hot-remove.patch

cd {kernel_path}
cp $GOPATH/src/github.com/kata-containers/kata-containers/tools/packaging/kernel/patches/5.4.x/0006-arm64-mm-Enable-memory-hot-remove.patch ..
patch -p1 <../0006-arm64-mm-Enable-memory-hot-remove.patch

CONFIG_ACPI_NFIT=y
CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
CONFIG_MEMORY_HOTREMOVE=y
CONFIG_ZONE_DEVICE=y
CONFIG_NVDIMM_PFN=y
CONFIG_NVDIMM_DAX=y

# If false and nvdimm is supported, use nvdimm device to plug guest image.
# Otherwise virtio-block device is used.
# Default is false
#disable_image_nvdimm = true   //这里不要打开
 
# -pflash can add image file to VM. The arguments of it should be in format
# of ["/path/to/flash0.img", "/path/to/flash1.img"]
pflashes = ["/usr/share/kata-containers/kata-flash0.img","/usr/share/kata-containers/kata-flash1.img"]  //这里指定uefi的rom

#!/bin/sh
mount -t tmpfs -o size=8192m tmpfs /tmp
mount -t tmpfs -o size=8192m tmpfs /var/log	

pub mod model {
    #[derive(Debug, Clone)]
    pub struct ProductModel {
        pub field1: String,
        pub field2: String,
        pub field3: i32,
        pub type_: String,
    }
}

for i in 1..sheet.get_highest_row()+1 {
	....
}

let name =element+"流";
报错：
cannot add `&str` to `&std::string::String`
string concatenation requires an owned `String` on the leftrustcClick for full compiler diagnostic

 let name = element.add("流");
 报错：
 cannot move out of `* element ` which is behind a shared reference
move occurs because `* element ` has type `std::string::String`, which does not implement the `Copy` traitrustcClick for full compiler diagnostic

let name =*element.add("流");
报错：
the size for values of type `str` cannot be known at compilation time
the trait `Sized` is not implemented for `str`
all local variables must have a statically known size
unsized locals are gated as an unstable feature

let name = String::from(element).add("流");

 let mut map: HashMap<String, Vec<Model>> = HashMap::new();
 ...
 for entry in map.iter() {
        let sheet_name = entry.0.clone().add("流");
        let sheet = book.get_sheet_by_name_mut(&sheet_name).unwrap();
        ...
}

pub mod dict {
	static mut map:HashMap<String,String> = HashMap::new();
}
报错：
cannot call non-const fn `HashMap::<std::string::String, std::string::String>::new` in statics
calls in statics are limited to constant functions, tuple structs and tuple variantsrustcClick for full compiler diagnostic

const mut map:HashMap<String,String> = HashMap::new();
报错：
const globals cannot be mutable    

const map:HashMap<String,String> = HashMap::new();
报错：
cannot call non-const fn `HashMap::<std::string::String, std::string::String>::new` in constants
calls in constants are limited to constant functions, tuple structs and tuple variantsrustcClick for full compiler diagnostic

pub mod dict {
    use std::{collections::HashMap, fs::File, io::Read, sync::Mutex};

    pub fn get_product_name(product_name: String) -> String {
        if let Some(value) = CONFIG_MAP.lock().unwrap().get(&product_name) {
            return value.to_owned();
        }
        return product_name;
    }
    lazy_static! {
        static ref CONFIG_MAP: Mutex<HashMap<String, String>> = {
            let mut file = File::open("./data/cfg.toml").unwrap();
            let mut data = String::new();
            file.read_to_string(&mut data).unwrap();
            let obj: HashMap<String, HashMap<String, String>> = toml::from_str(&data).unwrap();
            let dict_map = obj.get("product_dict").unwrap();
            Mutex::new(dict_map.clone())
        };
    }
}

# kata-runtime check
INFO[0000] IOMMUPlatform is disabled by default.
System is capable of running Kata Containers
System can currently create Kata Containers

$ sudo ctr image pull docker.io/library/busybox:latest
$ sudo ctr run --cni --runtime io.containerd.run.kata.v2 -t --rm docker.io/library/busybox:latest hello sh

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }