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

#include "render_remote.h"

    25

#include "config.h"

    26

#include "tile.h"

    27

#include "static.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

    INFO("render [%p]: sent headers", 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

        INFO("render [%p]: delaying data: %zu:%zu bytes", 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

    INFO("render [%p]: enqueued chunk: %zu/%zu bytes", 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

    INFO("render [%p]: done: %zu bytes", 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

    INFO("render [%p]: failed", 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

    INFO("render [%p]: lost http connection", 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

    INFO("render [%p]: http available for write", 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 int _http_render_execute (struct evhttp_request *request, struct render *render) {

   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

    // initiate the remote render operation

   170

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

   171

        &_render_sent,

   172

        &_render_data,

   173

        &_render_done,

   174

        &_render_fail,

   175

        ctx

   176

    )) == NULL)

   177

        ERROR("render_remote");

   178

   179

    // set chunk size

   180

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

   181

   182

    // set close cb

   183

    evhttp_set_reply_abortcb(request, &_render_http_lost, ctx);

   184

   185

    INFO("render [%p]: started", ctx);

   186

   187

    return 0;

   188

   189

error:

   190

    _render_cleanup(ctx);

   191

   192

    return -1;

   193

}

   194

   195

/*

   196

 * HTTP request handlers

   197

 */

   198

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

   199

    // gather some info about the request

   200

    const char *uri = evhttp_request_get_uri(request);

   201

    char *peer_address;

   202

    unsigned short peer_port;

   203

    struct render render;

   204

   205

    evhttp_request_get_peer(request, &peer_address, &peer_port);

   206

   207

    u_int32_t img_w = 256, img_h = 256;

   208

   209

    // parse request arguments

   210

    struct http_qarg qarg_spec[] = {

   211

        { "w",      QARG_UINT32,    &img_w, QARG_OPTIONAL   },

   212

        { "h",      QARG_UINT32,    &img_h, QARG_OPTIONAL   },

   213

        { NULL,     QARG_END,       NULL,   0               }

   214

    };

   215

   216

    if (http_qarg_parse(request, qarg_spec))

   217

        goto error;

   218

   219

    // build the render op

   220

    if (

   221

            render_init(&render)

   222

         || render_set_mode(&render, RENDER_PNG)

   223

         || render_set_size(&render, img_w, img_h)

   224

         || render_region_full(&render)

   225

    )

   226

        ERROR("render_*");

   227

   228

    // request log

   229

    INFO("REQ: [%s:%d] method=%d, uri=%s, img_w=%u, img_h=%u", peer_address, peer_port, evhttp_request_get_type(request), uri, img_w, img_h);

   230

   231

    // do it

   232

    if (_http_render_execute(request, &render))

   233

        goto error;

   234

   235

    return;

   236

   237

error:

   238

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

   239

}

   240

   241

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

   242

    // gather some info about the request

   243

    const char *uri = evhttp_request_get_uri(request);

   244

    char *peer_address;

   245

    unsigned short peer_port;

   246

    struct render render;

   247

   248

    evhttp_request_get_peer(request, &peer_address, &peer_port);

   249

   250

    u_int32_t x, y, sw, sh;

   251

    u_int16_t z;

   252

   253

    // parse request arguments

   254

    struct http_qarg qarg_spec[] = {

   255

        { "x",      QARG_UINT32,    &x,     QARG_REQUIRED   },

   256

        { "y",      QARG_UINT32,    &y,     QARG_REQUIRED   },

   257

        { "z",      QARG_UINT16,    &z,     QARG_REQUIRED   },

   258

        { "sw",     QARG_UINT32,    &sw,    QARG_REQUIRED   },

   259

        { "sh",     QARG_UINT32,    &sh,    QARG_REQUIRED   },

   260

        { NULL,     QARG_END,       NULL,   0               }

   261

    };

   262

   263

    if (http_qarg_parse(request, qarg_spec))

   264

        goto error;

   265

   266

    // build the render op

   267

    if (

   268

            render_init(&render)

   269

         || render_set_mode(&render, RENDER_PNG)

   270

         || render_set_tile(&render, sw, sh, x, y, z)

   271

    )

   272

        ERROR("render_*");

   273

   274

    // request log

   275

    INFO("REQ: [%s:%d] method=%d, uri=%s, pos=(%u, %u), zoom=%hu, screen=[%ux%u]", 

   276

        peer_address, peer_port, evhttp_request_get_type(request), uri, x, y, z, sw, sh);

   277

   278

    // do it

   279

    if (_http_render_execute(request, &render))

   280

        goto error;

   281

   282

    return;

   283

   284

error:

   285

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

   286

}

   287

   288

/*

   289

 * Signal handling

   290

 */

   291

struct event ev_sigint;

   292

   293

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

   294

    INFO("SIGINT: shutting down");

   295

   296

    if (event_base_loopexit(ev_base, NULL))

   297

        err_exit("event_loopexit");

   298

}

   299

   300

void signals_init () {

   301

    // handle SIGINT

   302

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

   303

    signal_add(&ev_sigint, NULL);

   304

   305

    // ignore SIGPIPE

   306

    struct sigaction sigpipe;

   307

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

   308

   309

    sigpipe.sa_handler = SIG_IGN;

   310

   311

    sigaction(SIGPIPE, &sigpipe, NULL);

   312

}

   313

   314

void signals_deinit () {

   315

    signal_del(&ev_sigint);

   316

}

   317

   318

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

   319

    // ignore

   320

}

   321

   322

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

   323

    // libevent init

   324

    ev_base = event_init();

   325

   326

    if (!ev_base)

   327

        FATAL("event_init");

   328

   329

    // set up our render node pool

   330

    remote_pool_init(&remote_pool);

   331

   332

    // process arguments

   333

    int opt;

   334

    int enable_debug = 0;

   335

   336

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

   337

        switch (opt) {

   338

            case 'p':

   339

                // populate the pool from a file

   340

                if (remote_pool_load(&remote_pool, optarg))

   341

                    return 1;

   342

   343

                break;

   344

   345

            case 'r':

   346

                // add the given render node to the pool

   347

                if (remote_pool_add(&remote_pool, optarg))

   348

                    return 1;

   349

   350

                break;

   351

   352

            case 'd':

   353

                // enable libevent debugging

   354

                enable_debug = 1;

   355

                break;

   356

   357

            default:

   358

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

   359

   360

        }

   361

    }

   362

   363

    int pool_size = remote_pool_size(&remote_pool);

   364

   365

    if (!pool_size)

   366

        FATAL("No remote render nodes given");

   367

   368

   369

    INFO("Registered %d render nodes in our pool", pool_size);

   370

   371

    // per default it is enabled

   372

    if (!enable_debug)

   373

        event_set_log_callback(&log_null);

   374

   375

    // handle signals

   376

    signals_init();

   377

   378

    // evhttp init

   379

    struct evhttp *http_server = evhttp_new(ev_base);

   380

   381

    if (!http_server)

   382

        FATAL("evhttp_new");

   383

   384

    // bind to the correct interface/port

   385

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

   386

        FATAL("evhttp_bind_socket");

   387

   388

    // add our http request handlers

   389

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

   390

    evhttp_set_cb(http_server, "/tile",     &http_tile,     NULL);

   391

   392

    // and then static files

   393

    struct static_file static_index;

   394

    struct static_dir static_files;

   395

   396

    if (static_init(&static_index, http_server, "/", "static/index.html"))

   397

        FATAL("static_init: index.html");

   398

   399

    if (static_dir_init(&static_files, http_server, "/static", "static"))

   400

        FATAL("static_dir_init: static");

   401

   402

    // we shall now run

   403

    INFO("RUN 0.0.0.0:8117");

   404

   405

    // run the libevent mainloop

   406

    if (event_base_dispatch(ev_base))

   407

        WARNING("event_dispatch");

   408

   409

    INFO("SHUTDOWN");

   410

   411

    // clean up

   412

    signals_deinit();

   413

    evhttp_free(http_server);

   414

    event_base_free(ev_base);

   415

   416

    // successfull exit

   417

    return 0;

   418

}