1

#include <sys/types.h>

     2

#include <sys/queue.h>

     3

#include <sys/socket.h>

     4

#include <stdlib.h>

     5

#include <stdio.h>

     6

#include <string.h>

     7

#include <netinet/ip.h>

     8

#include <arpa/inet.h>

     9

#include <signal.h>

    10

#include <unistd.h>

    11

#include <assert.h>

    12

    13

#include <event2/event.h>

    14

#include <event2/event_compat.h>

    15

#include <event2/http.h>

    16

#include <event2/event_struct.h>

    17

    18

#include "common.h"

    19

#include "http.h"

    20

#include "render_struct.h"

    21

#include "render.h"

    22

#include "remote_node.h"

    23

#include "remote_pool.h"

    24

    25

// XXX: replace with a common one

    26

#include "render_remote.h"

    27

#include "render_multi.h"

    28

    29

#define MIN_CHUNK_SIZE 4096

    30

#define OVERFLOW_BUFFER 4096

    31

    32

// do not do any userland socket output buffering

    33

#define HTTP_BUFFER 0

    34

    35

// what event_base we're using

    36

static struct event_base *ev_base;

    37

    38

// our render node pool

    39

static struct remote_pool remote_pool;

    40

    41

// info on a render request

    42

struct render_request {

    43

    struct evhttp_request *http_request;

    44

    45

    int headers_sent;

    46

    47

    struct render_remote *render_info;

    48

    49

    size_t bytes_sent;

    50

    51

    int paused;

    52

};

    53

    54

// cb func prototypes

    55

static void _render_http_written (struct evhttp_request *request, void *arg);

    56

    57

static void _render_cleanup (struct render_request *ctx) {

    58

    if (ctx->render_info)

    59

        render_remote_free(ctx->render_info);

    60

    61

    free(ctx);

    62

}

    63

    64

static void _render_sent (void *arg) {

    65

    struct render_request *ctx = arg;

    66

    67

    // send headers

    68

    evhttp_add_header(evhttp_request_get_output_headers(ctx->http_request), "Content-Type", "image/png");

    69

    evhttp_send_reply_start(ctx->http_request, HTTP_OK, "OK");

    70

    71

    // setup flow-control

    72

    evhttp_set_reply_notify(ctx->http_request, HTTP_BUFFER, &_render_http_written, ctx);

    73

    74

    ctx->headers_sent = 1;

    75

    76

    printf("render [%p]: sent headers\n", ctx);

    77

}

    78

    79

static void _render_data (struct evbuffer *buf, void *arg) {

    80

    struct render_request *ctx = arg;

    81

    82

    size_t buf_size = EVBUFFER_LENGTH(buf);

    83

    84

    assert(buf_size > 0);   // shouldn't happen anymore with the new render_remote

    85

    86

    // check if we are paused

    87

    if (ctx->paused) {

    88

        // we are waiting for the HTTP send buffer to clear, so keep the data in the render buffer

    89

        printf("render [%p]: delaying data: %zu:%zu bytes\n", ctx, buf_size, ctx->bytes_sent);

    90

    91

        return;

    92

    }

    93

    94

    // move chunk to http buffers

    95

    evhttp_send_reply_chunk(ctx->http_request, buf);

    96

    97

    printf("render [%p]: enqueued chunk: %zu/%zu bytes\n", ctx, buf_size, ctx->bytes_sent);

    98

    99

    // mark ourself as paused until httpd tells us to continue

   100

    ctx->paused = 1;

   101

   102

    // keep a tally of total sent bytes

   103

    ctx->bytes_sent += buf_size;

   104

}

   105

   106

static void _render_done (void *arg) {

   107

    struct render_request *ctx = arg;

   108

   109

    // send end

   110

    evhttp_send_reply_end(ctx->http_request);

   111

   112

    printf("render [%p]: done: %zu bytes\n", ctx, ctx->bytes_sent);

   113

   114

    // the request is now done, clean up

   115

    _render_cleanup(ctx);

   116

}

   117

   118

static void _render_fail (void *arg) {

   119

    struct render_request *ctx = arg;

   120

   121

    if (ctx->headers_sent) {

   122

        // just terminate the PNG stream where it is

   123

        evhttp_send_reply_end(ctx->http_request);

   124

   125

    } else {

   126

        evhttp_send_error(ctx->http_request, 500, "Internal Server Error");

   127

    }

   128

   129

    printf("render [%p]: failed\n", ctx);

   130

   131

    _render_cleanup(ctx);

   132

}

   133

   134

static void _render_http_lost (struct evhttp_request *req, void *arg) {

   135

    struct render_request *ctx = arg;

   136

   137

    printf("render [%p]: lost http connection\n", ctx);

   138

   139

    // cancel

   140

    render_remote_cancel(ctx->render_info);

   141

    ctx->render_info = NULL;

   142

   143

    _render_cleanup(ctx);

   144

}

   145

   146

static void _render_http_written (struct evhttp_request *request, void *arg) {

   147

    struct render_request *ctx = arg;

   148

   149

    printf("render [%p]: http available for write\n", ctx);

   150

   151

    // unpause ourself

   152

    ctx->paused = 0;

   153

   154

    // any data waiting in the buffer?

   155

    render_remote_flush(ctx->render_info);

   156

}

   157

   158

static void _http_render_execute (struct evhttp_request *request, u_int32_t img_w, u_int32_t img_h) {

   159

    // render request context

   160

    struct render_request *ctx = calloc(1, sizeof(struct render_request));

   161

   162

    if (!ctx)

   163

        ERROR("calloc");

   164

   165

    ctx->http_request = request;

   166

    ctx->headers_sent = 0;

   167

    ctx->bytes_sent = 0;

   168

   169

    // render context

   170

    struct render render;

   171

   179

   180

    // initiate the remote render operation

   181

    if ((ctx->render_info = render_remote(&render, &remote_pool,

   182

        &_render_sent,

   183

        &_render_data,

   184

        &_render_done,

   185

        &_render_fail,

   186

        ctx

   187

    )) == NULL)

   188

        ERROR("render_remote");

   189

   190

    // set chunk size

   191

    render_remote_set_recv(ctx->render_info, MIN_CHUNK_SIZE, OVERFLOW_BUFFER);

   192

   193

    // set close cb

   194

    evhttp_set_reply_abortcb(request, &_render_http_lost, ctx);

   195

   196

    printf("render [%p]: started\n", ctx);

   197

   198

    return;

   199

   200

error:

   201

    evhttp_send_error(request, 500, "Internal Server Error");

   202

   203

    _render_cleanup(ctx);

   204

}

   205

   206

/*

   207

 * HTTP request handler

   208

 */

   209

void http_render (struct evhttp_request *request, void *arg) {

   210

    // gather some info about the request

   211

    const char *uri = evhttp_request_get_uri(request);

   212

    char *peer_address;

   213

    u_short peer_port;

   214

   215

    evhttp_request_get_peer(request, &peer_address, &peer_port);

   216

   217

    unsigned long int img_w = 256, img_h = 256;

   218

   219

    // parse request arguments

   220

    struct http_qarg qarg_spec[] = {

   221

        { "w",      QARG_UINT,  &img_w  },

   222

        { "h",      QARG_UINT,  &img_h  },

   223

        { NULL,     QARG_END,   NULL    }

   224

    };

   225

   226

    http_qarg_parse(request, qarg_spec);

   227

   228

    // request log

   229

    printf("REQ: [%s:%d] method=%d, uri=%s, img_w=%lu, img_h=%lu\n", peer_address, peer_port, evhttp_request_get_type(request), uri, img_w, img_h);

   230

   231

    // do it

   232

    _http_render_execute(request, img_w, img_h);

   233

}

   234

   235

struct event ev_sigint;

   236

   237

void sigint_handler (int signal, short event, void *arg) {

   238

    printf("SIGINT: shutting down\n");

   239

   240

    if (event_base_loopexit(ev_base, NULL))

   241

        err_exit("event_loopexit");

   242

}

   243

   244

void signals_init () {

   245

    // handle SIGINT

   246

    signal_set(&ev_sigint, SIGINT, &sigint_handler, NULL);

   247

    signal_add(&ev_sigint, NULL);

   248

   249

    // ignore SIGPIPE

   250

    struct sigaction sigpipe;

   251

    memset(&sigpipe, 0, sizeof(sigpipe));

   252

   253

    sigpipe.sa_handler = SIG_IGN;

   254

   255

    sigaction(SIGPIPE, &sigpipe, NULL);

   256

}

   257

   258

void signals_deinit () {

   259

    signal_del(&ev_sigint);

   260

}

   261

   262

void log_null (int severity, const char *msg) {

   263

    // ignore

   264

}

   265

   266

int main (int argc, char **argv) {

   267

    // libevent init

   268

    ev_base = event_init();

   269

   270

    if (!ev_base)

   271

        FATAL("event_init");

   272

   273

    // set up our render node pool

   274

    remote_pool_init(&remote_pool);

   275

   276

    // process arguments

   277

    int opt;

   278

    int enable_debug = 0;

   279

    char *host, *port;

   280

   281

    while ((opt = getopt(argc, argv, "dp:r:")) != -1) {

   282

        switch (opt) {

   283

            case 'p':

   284

                // populate the pool from a file

   285

                if (remote_pool_load(&remote_pool, optarg))

   286

                    return 1;

   287

   288

                break;

   289

   290

            case 'r':

   291

                // add the given render node to the pool

   292

                if (

   293

                        parse_hostport(optarg, &host, &port)

   294

                     || remote_pool_add(&remote_pool, host, port)

   295

                )

   296

                    return 1;

   297

   298

                break;

   299

   300

            case 'd':

   301

                // enable libevent debugging

   302

                enable_debug = 1;

   303

                break;

   304

   305

            default:

   306

                err_exit("Usage: %s [-d] (-p pool_file | -r hostname[:port] | ...)", argv[0]);

   307

   308

        }

   309

    }

   310

   311

    int pool_size = remote_pool_size(&remote_pool);

   312

   313

    if (!pool_size)

   314

        FATAL("No remote render nodes given");

   315

   316

   317

    printf("Registered %d render nodes in our pool\n", pool_size);

   318

   319

    // per default it is enabled

   320

    if (!enable_debug)

   321

        event_set_log_callback(&log_null);

   322

   323

    // handle signals

   324

    signals_init();

   325

   326

    // evhttp init

   327

    struct evhttp *http_server = evhttp_new(ev_base);

   328

   329

    if (!http_server)

   330

        FATAL("evhttp_new");

   331

   332

    // bind to the correct interface/port

   333

    if (evhttp_bind_socket(http_server, "0.0.0.0", 8117))

   334

        FATAL("evhttp_bind_socket");

   335

   336

    // add our http request handler

   337

    evhttp_set_cb(http_server, "/render", &http_render, NULL);

   338

   339

    // we shall now run

   340

    printf("RUN 0.0.0.0:8117\n");

   341

   342

    // run the libevent mainloop

   343

    if (event_base_dispatch(ev_base))

   344

        WARNING("event_dispatch");

   345

   346

    printf("SHUTDOWN\n");

   347

   348

    // clean up

   349

    signals_deinit();

   350

    evhttp_free(http_server);

   351

    event_base_free(ev_base);

   352

   353

    // successfull exit

   354

    return 0;

   355

}