11  * Execute a render_t operation on a remote render_node

    11  * Execute a render operation on a remote render_node

    17 struct remote_render_ctx;

    17 struct render_remote;

    20  * Execute the given render operation on the render_node at the given remote address.

    20  * Execute the given render operation on the render_node at the given remote

    21  * address, and buffer the data stream.

    22  * The various callback functions must all be provided.

    23  * The various callback functions must all be provided!

    24  * cb_sent will be invoked after the request has succesfully been written, and before cb_data is called.

    25  * cb_sent

    25  * cb_data is called whenever new data has been received. See also, render_remote_set_chunk_size

    26  *  Will be invoked once we have a pretty good guess that the render will

    26  * cb_done is called after our last call to cb_data (note: see render_remote_shake)

    27  *  complete succesfully.

    27  * cb_fail is called when an error is encountered. This can (and will) happen at any time!

    29  * Returns NULL on error, or a handle that can be used for cancel/etc on success

    29  * cb_data

    30  *  Will be invoked after cb_sent has been called whenever any new data has

    31  *  been received into our buffer, once we've buffered all the data, or after

    32  *  render_remote_flush.

    33  *

    34  * cb_done

    35  *  The request was terminated succesfully and all data has been read out of

    36  *  our buffer by cb_data

    37  *

    38  * cb_fail 

    39  *  The request was terminated abnormally. This may happen at any time, except

    40  *  after cb_done has been called.

    41  *

    42  * The returned struct render_remote can be used as a handle for the control

    43  * functions, and it is the caller's responsibility to free it using

    44  * render_remote_free after cb_done/cb_fail has been called, or alternatively,

    45  * cancel it using render_remote_cancel.

    46  *

    47  * Returns NULL on error, or a handle on success

    31 struct remote_render_ctx *render_remote (

    49 struct render_remote *render_remote (

    42  * Cancel the given request. No more callbacks will be called, buffered data is

    60  * Execute the given render operation on the render_node at the given remote

    43  * discarded and the remote render process will cancel ASAP.

    61  * address, and let the user handle the read I/O events.

    62  *

    63  * The various callback functions must all be provided!

    64  *

    65  * cb_sent

    66  *  Will be called once the request has been sent.

    67  *

    68  * cb_fail

    69  *  Will be called if sending the request fails.

    70  *

    71  * cb_io_data

    72  *  Will be called once when there is data on the socket to receive. Must be

    73  *  re-enabled using render_remote_again each time.

    45 void render_remote_cancel (struct remote_render_ctx *ctx);

    75 struct render_remote *render_remote_rawio (

    76         struct render *render,

    77         struct remote_node *remote_node,

    78         void (*cb_sent)(void *arg),

    79         void (*cb_fail)(void *arg),

    80         void (*cb_io_data)(evutil_socket_t, short, void*),

    81         void *cb_arg

    82 );

    62  * MUST call render_remote_shake once you are ready to start consuming the

    99  * MUST call render_remote_again once you are ready to start consuming the

    65  * Only call this once cb_sent has fired

   102  * Only valid for normal buffered renders.

    67 int render_remote_set_recv (struct remote_render_ctx *ctx, size_t recv_threshold, size_t unread_buffer);

   104 void render_remote_set_recv (struct render_remote *ctx, size_t recv_threshold, size_t unread_buffer);

    70  * Call cb_data with the current set of buffered input data immediately,

   107  * For buffered I/O, call cb_data with the current set of buffered input data

    71  * regardless of whether or not the buffer contains any data, or any new

   108  * immediately, regardless of whether or not the buffer contains any data, or

    72  * data has been received.

   109  * any new data has been received. Only call this once cb_sent has been invoked.

   110  */

   111 void render_remote_flush (struct render_remote *ctx);

   112 

   113 /*

   114  * For non-buffered I/O, reschedule the cb_io_data event to be called when more

   115  * data is received.

   116  */

   117 int render_remote_reschedule (struct render_remote *ctx);

   118 

   119 /*

   120  * Cancel the given request. No more callbacks will be called, the ctx is freed

   121  * and the remote render process will cancel ASAP.

    74  * Only call this after cb_sent and before cb_done/cb_fail.

   123  * For buffered I/O, the any buffered data is discarded.

   124  *

   125  * Note that you do not need to call render_remote_free after this.

    76 int render_remote_shake (struct remote_render_ctx *ctx);

   127 void render_remote_cancel (struct render_remote *ctx);

   128 

   129 /*

   130  * Free the render_remote ctx and its assoicated resources. Only valid after a

   131  * cb_done/cb_fail, otherwise use render_remote_cancel.

   132  */

   133 void render_remote_free (struct render_remote *ctx);