agoo 2.15.7 → 2.15.9

Sign up to get free protection for your applications and to get access to all the features.
Files changed (17) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +18 -0
  3. data/bin/agoo +47 -39
  4. data/ext/agoo/bind.c +209 -198
  5. data/ext/agoo/con.c +19 -9
  6. data/ext/agoo/con.h +2 -0
  7. data/ext/agoo/req.c +7 -0
  8. data/ext/agoo/req.h +2 -0
  9. data/ext/agoo/request.c +29 -0
  10. data/ext/agoo/rgraphql.c +7 -4
  11. data/ext/agoo/rserver.c +714 -688
  12. data/ext/agoo/rserver.h +1 -0
  13. data/ext/agoo/server.c +255 -253
  14. data/lib/agoo/version.rb +1 -1
  15. data/lib/agoo.rb +1 -0
  16. data/lib/rack/handler/agoo.rb +138 -130
  17. metadata +2 -2
data/ext/agoo/rserver.c CHANGED
@@ -35,64 +35,64 @@
35
35
  #include "upgraded.h"
36
36
  #include "websocket.h"
37
37
 
38
- extern void agoo_shutdown();
39
- extern sig_atomic_t agoo_stop;
38
+ extern void agoo_shutdown();
39
+ extern sig_atomic_t agoo_stop;
40
40
 
41
- static VALUE server_mod = Qundef;
41
+ static VALUE server_mod = Qundef;
42
42
 
43
- static VALUE connect_sym;
44
- static VALUE delete_sym;
45
- static VALUE get_sym;
46
- static VALUE head_sym;
47
- static VALUE options_sym;
48
- static VALUE post_sym;
49
- static VALUE push_env_key;
50
- static VALUE put_sym;
51
- static VALUE patch_sym;
43
+ static VALUE connect_sym;
44
+ static VALUE delete_sym;
45
+ static VALUE get_sym;
46
+ static VALUE head_sym;
47
+ static VALUE options_sym;
48
+ static VALUE post_sym;
49
+ static VALUE push_env_key;
50
+ static VALUE put_sym;
51
+ static VALUE patch_sym;
52
52
 
53
- static VALUE rserver;
53
+ static VALUE rserver;
54
54
 
55
- static ID call_id;
56
- static ID each_id;
57
- static ID on_close_id;
58
- static ID on_drained_id;
59
- static ID on_error_id;
60
- static ID on_message_id;
61
- static ID on_request_id;
62
- static ID to_i_id;
55
+ static ID call_id;
56
+ static ID each_id;
57
+ static ID on_close_id;
58
+ static ID on_drained_id;
59
+ static ID on_error_id;
60
+ static ID on_message_id;
61
+ static ID on_request_id;
62
+ static ID to_i_id;
63
63
 
64
- static const char err500[] = "HTTP/1.1 500 Internal Server Error\r\n";
64
+ static const char err500[] = "HTTP/1.1 500 Internal Server Error\r\n";
65
65
 
66
- static double poll_timeout = 0.1;
67
- struct _rServer the_rserver = {};
66
+ static double poll_timeout = 0.1;
67
+ struct _rServer the_rserver = {};
68
68
 
69
69
  static void
70
70
  server_mark(void *ptr) {
71
- agooUpgraded up;
71
+ agooUpgraded up;
72
72
 
73
73
  rb_gc_mark(rserver);
74
74
  pthread_mutex_lock(&agoo_server.up_lock);
75
75
  for (up = agoo_server.up_list; NULL != up; up = up->next) {
76
- if (Qnil != (VALUE)up->ctx) {
77
- rb_gc_mark((VALUE)up->ctx);
78
- }
79
- if (Qnil != (VALUE)up->env) {
80
- rb_gc_mark((VALUE)up->env);
81
- }
82
- if (Qnil != (VALUE)up->wrap) {
83
- rb_gc_mark((VALUE)up->wrap);
84
- }
76
+ if (Qnil != (VALUE)up->ctx) {
77
+ rb_gc_mark((VALUE)up->ctx);
78
+ }
79
+ if (Qnil != (VALUE)up->env) {
80
+ rb_gc_mark((VALUE)up->env);
81
+ }
82
+ if (Qnil != (VALUE)up->wrap) {
83
+ rb_gc_mark((VALUE)up->wrap);
84
+ }
85
85
  }
86
86
  pthread_mutex_unlock(&agoo_server.up_lock);
87
87
  }
88
88
 
89
89
  static void
90
90
  url_bind(VALUE rurl) {
91
- struct _agooErr err = AGOO_ERR_INIT;
92
- agooBind b = agoo_bind_url(&err, StringValuePtr(rurl));
91
+ struct _agooErr err = AGOO_ERR_INIT;
92
+ agooBind b = agoo_bind_url(&err, StringValuePtr(rurl));
93
93
 
94
94
  if (AGOO_ERR_OK != err.code) {
95
- rb_raise(rb_eArgError, "%s", err.msg);
95
+ rb_raise(rb_eArgError, "%s", err.msg);
96
96
  }
97
97
  agoo_server_bind(b);
98
98
  }
@@ -100,10 +100,11 @@ url_bind(VALUE rurl) {
100
100
  static int
101
101
  configure(agooErr err, int port, const char *root, VALUE options) {
102
102
  if (AGOO_ERR_OK != agoo_pages_set_root(err, root)) {
103
- return err->code;
103
+ return err->code;
104
104
  }
105
105
  agoo_server.thread_cnt = 0;
106
106
  the_rserver.worker_cnt = 1;
107
+ the_rserver.forker = Qnil;
107
108
  the_rserver.uses = NULL;
108
109
  atomic_init(&agoo_server.running, 0);
109
110
  agoo_server.listen_thread = 0;
@@ -112,165 +113,176 @@ configure(agooErr err, int port, const char *root, VALUE options) {
112
113
  agoo_server.binds = NULL;
113
114
 
114
115
  if (Qnil != options) {
115
- VALUE v;
116
-
117
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("thread_count"))))) {
118
- int tc = FIX2INT(v);
119
-
120
- if (1 <= tc || tc < 1000) {
121
- agoo_server.thread_cnt = tc;
122
- } else {
123
- rb_raise(rb_eArgError, "thread_count must be between 1 and 1000.");
124
- }
125
- }
126
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("worker_count"))))) {
127
- int wc = FIX2INT(v);
128
-
129
- if (1 <= wc || wc < MAX_WORKERS) {
130
- the_rserver.worker_cnt = wc;
131
- } else {
132
- rb_raise(rb_eArgError, "thread_count must be between 1 and %d.", MAX_WORKERS);
133
- }
134
- }
135
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("poll_timeout"))))) {
136
- double timeout = rb_num2dbl(v);
137
-
138
- if (0.0001 <= timeout || timeout < 1.0) {
139
- poll_timeout = timeout;
140
- } else {
141
- rb_raise(rb_eArgError, "poll_timeout must be between 0.0001 and 1.0.");
142
- }
143
- }
144
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_push_pending"))))) {
145
- int mpp = FIX2INT(v);
146
-
147
- if (0 <= mpp || mpp < 1000) {
148
- agoo_server.max_push_pending = mpp;
149
- } else {
150
- rb_raise(rb_eArgError, "max_push_pending must be between 0 and 1000.");
151
- }
152
- }
153
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("pedantic"))))) {
154
- agoo_server.pedantic = (Qtrue == v);
155
- }
156
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("root_first"))))) {
157
- agoo_server.root_first = (Qtrue == v);
158
- }
159
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("Port"))))) {
160
- if (rb_cInteger == rb_obj_class(v)) {
161
- port = NUM2INT(v);
162
- } else {
163
- switch (rb_type(v)) {
164
- case T_STRING:
165
- port = atoi(StringValuePtr(v));
166
- break;
167
- case T_FIXNUM:
168
- port = NUM2INT(v);
169
- break;
170
- default:
171
- break;
172
- }
173
- }
174
- }
175
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("ssl_cert"))))) {
176
- rb_check_type(v, T_STRING);
177
- const char *cert =StringValuePtr(v);
178
-
179
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("ssl_key"))))) {
180
- rb_check_type(v, T_STRING);
181
- const char *key =StringValuePtr(v);
182
-
183
- if (AGOO_ERR_OK != agoo_server_ssl_init(err, cert, key)) {
184
- rb_raise(rb_eArgError, "%s", err->msg);
185
- }
186
- } else {
187
- rb_raise(rb_eArgError, "An ssl_key must be provided if an ssl_cert was provided.");
188
- }
189
- }
190
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("bind"))))) {
191
- int len;
192
- int i;
193
-
194
- switch (rb_type(v)) {
195
- case T_STRING:
196
- url_bind(v);
197
- break;
198
- case T_ARRAY:
199
- len = (int)RARRAY_LEN(v);
200
- for (i = 0; i < len; i++) {
201
- url_bind(rb_ary_entry(v, i));
202
- }
203
- break;
204
- default:
205
- rb_raise(rb_eArgError, "bind option must be a String or Array of Strings.");
206
- break;
207
- }
208
- }
209
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("graphql"))))) {
210
- const char *path;
211
- agooHook get_hook;
212
- agooHook post_hook;
213
- agooHook options_hook;
214
- agooHook head = NULL;
215
- long plen;
216
- VALUE hide_schema = Qnil;
217
-
218
- rb_check_type(v, T_STRING);
219
- if (AGOO_ERR_OK != gql_init(err)) {
220
- return err->code;
221
- }
222
- path = StringValuePtr(v);
223
- plen = (long)RSTRING_LEN(v);
224
-
225
- get_hook = agoo_hook_func_create(AGOO_GET, path, gql_eval_get_hook, &agoo_server.eval_queue);
226
- post_hook = agoo_hook_func_create(AGOO_POST, path, gql_eval_post_hook, &agoo_server.eval_queue);
227
- options_hook = agoo_hook_func_create(AGOO_OPTIONS, path, gql_eval_options_hook, &agoo_server.eval_queue);
228
- if (Qnil != (hide_schema = rb_hash_lookup(options, ID2SYM(rb_intern("hide_schema")))) && Qtrue == hide_schema) {
229
- head = get_hook;
230
- } else {
231
- char schema_path[256];
232
- agooHook dump_hook;
233
-
234
- if ((int)sizeof(schema_path) - 8 < plen) {
235
- rb_raise(rb_eArgError, "A graphql schema path is limited to %d characters.", (int)(sizeof(schema_path) - 8));
236
- }
237
- memcpy(schema_path, path, plen);
238
- memcpy(schema_path + plen, "/schema", 8);
239
- dump_hook = agoo_hook_func_create(AGOO_GET, schema_path, gql_dump_hook, &agoo_server.eval_queue);
240
- dump_hook->next = get_hook;
241
- head = dump_hook;
242
- }
243
- get_hook->next = post_hook;
244
- post_hook->next = options_hook;
245
- options_hook->next = agoo_server.hooks;
246
- agoo_server.hooks = head;
247
- }
248
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("quiet"))))) {
249
- if (Qtrue == v) {
250
- agoo_info_cat.on = false;
251
- }
252
- }
253
- if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("debug"))))) {
254
- if (Qtrue == v) {
255
- agoo_error_cat.on = true;
256
- agoo_warn_cat.on = true;
257
- agoo_info_cat.on = true;
258
- agoo_debug_cat.on = true;
259
- agoo_con_cat.on = true;
260
- agoo_req_cat.on = true;
261
- agoo_resp_cat.on = true;
262
- agoo_eval_cat.on = true;
263
- agoo_push_cat.on = true;
264
- }
265
- }
116
+ VALUE v;
117
+
118
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("thread_count"))))) {
119
+ int tc = FIX2INT(v);
120
+
121
+ if (1 <= tc || tc < 1000) {
122
+ agoo_server.thread_cnt = tc;
123
+ } else {
124
+ rb_raise(rb_eArgError, "thread_count must be between 1 and 1000.");
125
+ }
126
+ }
127
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("worker_count"))))) {
128
+ int wc = FIX2INT(v);
129
+
130
+ if (1 <= wc || wc < MAX_WORKERS) {
131
+ the_rserver.worker_cnt = wc;
132
+ } else {
133
+ rb_raise(rb_eArgError, "thread_count must be between 1 and %d.", MAX_WORKERS);
134
+ }
135
+ }
136
+ the_rserver.forker = rb_hash_lookup(options, ID2SYM(rb_intern("fork_wrap")));
137
+
138
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("poll_timeout"))))) {
139
+ double timeout = rb_num2dbl(v);
140
+
141
+ if (0.0001 <= timeout || timeout < 1.0) {
142
+ poll_timeout = timeout;
143
+ } else {
144
+ rb_raise(rb_eArgError, "poll_timeout must be between 0.0001 and 1.0.");
145
+ }
146
+ }
147
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("connection_timeout"))))) {
148
+ double timeout = rb_num2dbl(v);
149
+
150
+ if (0.1 <= timeout) {
151
+ con_timeout = timeout;
152
+ } else {
153
+ rb_raise(rb_eArgError, "connection_timeout must be greater than 0.1 seconds.");
154
+ }
155
+ }
156
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_push_pending"))))) {
157
+ int mpp = FIX2INT(v);
158
+
159
+ if (0 <= mpp || mpp < 1000) {
160
+ agoo_server.max_push_pending = mpp;
161
+ } else {
162
+ rb_raise(rb_eArgError, "max_push_pending must be between 0 and 1000.");
163
+ }
164
+ }
165
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("pedantic"))))) {
166
+ agoo_server.pedantic = (Qtrue == v);
167
+ }
168
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("root_first"))))) {
169
+ agoo_server.root_first = (Qtrue == v);
170
+ }
171
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("Port"))))) {
172
+ if (rb_cInteger == rb_obj_class(v)) {
173
+ port = NUM2INT(v);
174
+ } else {
175
+ switch (rb_type(v)) {
176
+ case T_STRING:
177
+ port = atoi(StringValuePtr(v));
178
+ break;
179
+ case T_FIXNUM:
180
+ port = NUM2INT(v);
181
+ break;
182
+ default:
183
+ break;
184
+ }
185
+ }
186
+ }
187
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("ssl_cert"))))) {
188
+ rb_check_type(v, T_STRING);
189
+ const char *cert =StringValuePtr(v);
190
+
191
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("ssl_key"))))) {
192
+ rb_check_type(v, T_STRING);
193
+ const char *key =StringValuePtr(v);
194
+
195
+ if (AGOO_ERR_OK != agoo_server_ssl_init(err, cert, key)) {
196
+ rb_raise(rb_eArgError, "%s", err->msg);
197
+ }
198
+ } else {
199
+ rb_raise(rb_eArgError, "An ssl_key must be provided if an ssl_cert was provided.");
200
+ }
201
+ }
202
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("bind"))))) {
203
+ int len;
204
+ int i;
205
+
206
+ switch (rb_type(v)) {
207
+ case T_STRING:
208
+ url_bind(v);
209
+ break;
210
+ case T_ARRAY:
211
+ len = (int)RARRAY_LEN(v);
212
+ for (i = 0; i < len; i++) {
213
+ url_bind(rb_ary_entry(v, i));
214
+ }
215
+ break;
216
+ default:
217
+ rb_raise(rb_eArgError, "bind option must be a String or Array of Strings.");
218
+ break;
219
+ }
220
+ }
221
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("graphql"))))) {
222
+ const char *path;
223
+ agooHook get_hook;
224
+ agooHook post_hook;
225
+ agooHook options_hook;
226
+ agooHook head = NULL;
227
+ long plen;
228
+ VALUE hide_schema = Qnil;
229
+
230
+ rb_check_type(v, T_STRING);
231
+ if (AGOO_ERR_OK != gql_init(err)) {
232
+ return err->code;
233
+ }
234
+ path = StringValuePtr(v);
235
+ plen = (long)RSTRING_LEN(v);
236
+
237
+ get_hook = agoo_hook_func_create(AGOO_GET, path, gql_eval_get_hook, &agoo_server.eval_queue);
238
+ post_hook = agoo_hook_func_create(AGOO_POST, path, gql_eval_post_hook, &agoo_server.eval_queue);
239
+ options_hook = agoo_hook_func_create(AGOO_OPTIONS, path, gql_eval_options_hook, &agoo_server.eval_queue);
240
+ if (Qnil != (hide_schema = rb_hash_lookup(options, ID2SYM(rb_intern("hide_schema")))) && Qtrue == hide_schema) {
241
+ head = get_hook;
242
+ } else {
243
+ char schema_path[256];
244
+ agooHook dump_hook;
245
+
246
+ if ((int)sizeof(schema_path) - 8 < plen) {
247
+ rb_raise(rb_eArgError, "A graphql schema path is limited to %d characters.", (int)(sizeof(schema_path) - 8));
248
+ }
249
+ memcpy(schema_path, path, plen);
250
+ memcpy(schema_path + plen, "/schema", 8);
251
+ dump_hook = agoo_hook_func_create(AGOO_GET, schema_path, gql_dump_hook, &agoo_server.eval_queue);
252
+ dump_hook->next = get_hook;
253
+ head = dump_hook;
254
+ }
255
+ get_hook->next = post_hook;
256
+ post_hook->next = options_hook;
257
+ options_hook->next = agoo_server.hooks;
258
+ agoo_server.hooks = head;
259
+ }
260
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("quiet"))))) {
261
+ if (Qtrue == v) {
262
+ agoo_info_cat.on = false;
263
+ }
264
+ }
265
+ if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("debug"))))) {
266
+ if (Qtrue == v) {
267
+ agoo_error_cat.on = true;
268
+ agoo_warn_cat.on = true;
269
+ agoo_info_cat.on = true;
270
+ agoo_debug_cat.on = true;
271
+ agoo_con_cat.on = true;
272
+ agoo_req_cat.on = true;
273
+ agoo_resp_cat.on = true;
274
+ agoo_eval_cat.on = true;
275
+ agoo_push_cat.on = true;
276
+ }
277
+ }
266
278
  }
267
279
  if (0 < port) {
268
- agooBind b = agoo_bind_port(err, port);
280
+ agooBind b = agoo_bind_port(err, port);
269
281
 
270
- if (AGOO_ERR_OK != err->code) {
271
- rb_raise(rb_eArgError, "%s", err->msg);
272
- }
273
- agoo_server_bind(b);
282
+ if (AGOO_ERR_OK != err->code) {
283
+ rb_raise(rb_eArgError, "%s", err->msg);
284
+ }
285
+ agoo_server_bind(b);
274
286
  }
275
287
  return AGOO_ERR_OK;
276
288
  }
@@ -295,13 +307,15 @@ configure(agooErr err, int port, const char *root, VALUE options) {
295
307
  *
296
308
  * - *:poll_timeout* [_Float_] timeout seconds when polling. Default is 0.1. Lower gives faster response times but uses more CPU.
297
309
  *
310
+ * - *:connection_timeout* [_Float_] timeout seconds for connections. Default is 30.
311
+ *
298
312
  * - *:bind* [_String_|_Array_] a binding or array of binds. Examples are: "http ://127.0.0.1:6464", "unix:///tmp/agoo.socket", "http ://[::1]:6464, or to not restrict the address "http ://:6464".
299
313
  *
300
314
  * - *:graphql* [_String_] path to GraphQL endpoint if support for GraphQL is desired.
301
315
  *
302
316
  * - *:max_push_pending* [_Integer_] maximum number or outstanding push messages, less than 1000.
303
317
  *
304
- * - *:ssl_sert* [_String_] filepath to the SSL certificate file.
318
+ * - *:ssl_cert* [_String_] filepath to the SSL certificate file.
305
319
  *
306
320
  * - *:ssl_key* [_String_] filepath to the SSL private key file.
307
321
  *
@@ -309,83 +323,83 @@ configure(agooErr err, int port, const char *root, VALUE options) {
309
323
  */
310
324
  static VALUE
311
325
  rserver_init(int argc, VALUE *argv, VALUE self) {
312
- struct _agooErr err = AGOO_ERR_INIT;
313
- int port;
314
- const char *root;
315
- VALUE options = Qnil;
326
+ struct _agooErr err = AGOO_ERR_INIT;
327
+ int port;
328
+ const char *root;
329
+ VALUE options = Qnil;
316
330
 
317
331
  if (argc < 2 || 3 < argc) {
318
- rb_raise(rb_eArgError, "Wrong number of arguments to Agoo::Server.configure.");
332
+ rb_raise(rb_eArgError, "Wrong number of arguments to Agoo::Server.configure.");
319
333
  }
320
334
  port = FIX2INT(argv[0]);
321
335
  rb_check_type(argv[1], T_STRING);
322
336
  root = StringValuePtr(argv[1]);
323
337
  if (3 <= argc) {
324
- options = argv[2];
338
+ options = argv[2];
325
339
  }
326
340
  if (AGOO_ERR_OK != agoo_server_setup(&err)) {
327
- rb_raise(rb_eStandardError, "%s", err.msg);
341
+ rb_raise(rb_eStandardError, "%s", err.msg);
328
342
  }
329
343
  agoo_server.ctx_nil_value = (void*)Qnil;
330
344
  agoo_server.env_nil_value = (void*)Qnil;
331
345
 
332
346
  if (AGOO_ERR_OK != configure(&err, port, root, options)) {
333
- rb_raise(rb_eArgError, "%s", err.msg);
347
+ rb_raise(rb_eArgError, "%s", err.msg);
334
348
  }
335
349
  agoo_server.inited = true;
336
350
 
337
351
  return Qnil;
338
352
  }
339
353
 
340
- static const char bad500[] = "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: ";
354
+ static const char bad500[] = "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: ";
341
355
 
342
356
  static VALUE
343
357
  rescue_error(VALUE x, VALUE ignore) {
344
- agooReq req = (agooReq)x;
345
- volatile VALUE info = rb_errinfo();
346
- volatile VALUE msg = rb_funcall(info, rb_intern("message"), 0);
347
- const char *classname = rb_obj_classname(info);
348
- const char *ms = rb_string_value_ptr(&msg);
358
+ agooReq req = (agooReq)x;
359
+ volatile VALUE info = rb_errinfo();
360
+ volatile VALUE msg = rb_funcall(info, rb_intern("message"), 0);
361
+ const char *classname = rb_obj_classname(info);
362
+ const char *ms = rb_string_value_ptr(&msg);
349
363
 
350
364
  if (NULL == req->up) {
351
- char buf[1024];
352
- int len = (int)(strlen(classname) + 2 + strlen(ms));
353
- int cnt;
354
- agooText message;
355
-
356
- if ((int)(sizeof(buf) - sizeof(bad500) + 7) <= len) {
357
- len = sizeof(buf) - sizeof(bad500) + 7;
358
- }
359
- cnt = snprintf(buf, sizeof(buf), "%s%d\r\n\r\n%s: %s", bad500, len, classname, ms);
360
- message = agoo_text_create(buf, cnt);
361
-
362
- req->res->close = true;
363
- agoo_res_message_push(req->res, message);
364
- agoo_queue_wakeup(&agoo_server.con_queue);
365
+ char buf[1024];
366
+ int len = (int)(strlen(classname) + 2 + strlen(ms));
367
+ int cnt;
368
+ agooText message;
369
+
370
+ if ((int)(sizeof(buf) - sizeof(bad500) + 7) <= len) {
371
+ len = sizeof(buf) - sizeof(bad500) + 7;
372
+ }
373
+ cnt = snprintf(buf, sizeof(buf), "%s%d\r\n\r\n%s: %s", bad500, len, classname, ms);
374
+ message = agoo_text_create(buf, cnt);
375
+
376
+ req->res->close = true;
377
+ agoo_res_message_push(req->res, message);
378
+ agoo_queue_wakeup(&agoo_server.con_queue);
365
379
  } else {
366
380
  /*
367
- volatile VALUE bt = rb_funcall(info, rb_intern("backtrace"), 0);
368
- int blen = RARRAY_LEN(bt);
369
- int i;
370
- VALUE rline;
371
-
372
- for (i = 0; i < blen; i++) {
373
- rline = rb_ary_entry(bt, i);
374
- }
381
+ volatile VALUE bt = rb_funcall(info, rb_intern("backtrace"), 0);
382
+ int blen = RARRAY_LEN(bt);
383
+ int i;
384
+ VALUE rline;
385
+
386
+ for (i = 0; i < blen; i++) {
387
+ rline = rb_ary_entry(bt, i);
388
+ }
375
389
  */
376
- agoo_log_cat(&agoo_error_cat, "%s: %s", classname, ms);
390
+ agoo_log_cat(&agoo_error_cat, "%s: %s", classname, ms);
377
391
  }
378
392
  return Qfalse;
379
393
  }
380
394
 
381
395
  static VALUE
382
396
  handle_base_inner(VALUE x) {
383
- agooReq req = (agooReq)(void*)x;
384
- volatile VALUE rr = request_wrap(req);
385
- volatile VALUE rres = response_new();
397
+ agooReq req = (agooReq)(void*)x;
398
+ volatile VALUE rr = request_wrap(req);
399
+ volatile VALUE rres = response_new();
386
400
 
387
401
  if (NULL != req->hook) {
388
- rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
402
+ rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
389
403
  }
390
404
  DATA_PTR(rr) = NULL;
391
405
  agoo_res_message_push(req->res, response_text(rres));
@@ -403,45 +417,45 @@ handle_base(void *x) {
403
417
 
404
418
  static int
405
419
  header_cb(VALUE key, VALUE value, VALUE tv) {
406
- agooText *tp = (agooText*)tv;
407
- const char *ks = StringValuePtr(key);
408
- int klen = (int)RSTRING_LEN(key);
409
- const char *vs = StringValuePtr(value);
410
- int vlen = (int)RSTRING_LEN(value);
411
- struct _agooErr err = AGOO_ERR_INIT;
420
+ agooText *tp = (agooText*)tv;
421
+ const char *ks = StringValuePtr(key);
422
+ int klen = (int)RSTRING_LEN(key);
423
+ const char *vs = StringValuePtr(value);
424
+ int vlen = (int)RSTRING_LEN(value);
425
+ struct _agooErr err = AGOO_ERR_INIT;
412
426
 
413
427
  if (agoo_server.pedantic) {
414
- if (AGOO_ERR_OK != agoo_http_header_ok(&err, ks, klen, vs, vlen)) {
415
- rb_raise(rb_eArgError, "%s", err.msg);
416
- }
428
+ if (AGOO_ERR_OK != agoo_http_header_ok(&err, ks, klen, vs, vlen)) {
429
+ rb_raise(rb_eArgError, "%s", err.msg);
430
+ }
417
431
  }
418
432
  if (0 != strcasecmp("Content-Length", ks)) {
419
- char *end = index(vs, '\n');
420
-
421
- do {
422
- end = index(vs, '\n');
423
- *tp = agoo_text_append(*tp, ks, klen);
424
- *tp = agoo_text_append(*tp, ": ", 2);
425
- if (NULL == end) {
426
- if (0 < vlen) {
427
- *tp = agoo_text_append(*tp, vs, vlen);
428
- }
429
- } else {
430
- if (vs < end) {
431
- *tp = agoo_text_append(*tp, vs, (int)(end - vs));
432
- }
433
- vlen -= end - vs + 1;
434
- vs = end + 1;
435
- }
436
- *tp = agoo_text_append(*tp, "\r\n", 2);
437
- } while (NULL != end && 0 < vlen);
433
+ char *end = index(vs, '\n');
434
+
435
+ do {
436
+ end = index(vs, '\n');
437
+ *tp = agoo_text_append(*tp, ks, klen);
438
+ *tp = agoo_text_append(*tp, ": ", 2);
439
+ if (NULL == end) {
440
+ if (0 < vlen) {
441
+ *tp = agoo_text_append(*tp, vs, vlen);
442
+ }
443
+ } else {
444
+ if (vs < end) {
445
+ *tp = agoo_text_append(*tp, vs, (int)(end - vs));
446
+ }
447
+ vlen -= end - vs + 1;
448
+ vs = end + 1;
449
+ }
450
+ *tp = agoo_text_append(*tp, "\r\n", 2);
451
+ } while (NULL != end && 0 < vlen);
438
452
  }
439
453
  return ST_CONTINUE;
440
454
  }
441
455
 
442
456
  static VALUE
443
457
  header_each_cb(VALUE kv, VALUE cb_arg, int argc, const VALUE *argv, VALUE blockarg) {
444
- agooText *tp = (agooText*)cb_arg;
458
+ agooText *tp = (agooText*)cb_arg;
445
459
 
446
460
  header_cb(rb_ary_entry(kv, 0), rb_ary_entry(kv, 1), (VALUE)tp);
447
461
 
@@ -450,7 +464,7 @@ header_each_cb(VALUE kv, VALUE cb_arg, int argc, const VALUE *argv, VALUE blocka
450
464
 
451
465
  static VALUE
452
466
  body_len_cb(VALUE v, VALUE cb_arg, int argc, const VALUE *argv, VALUE blockarg) {
453
- int *sizep = (int*)cb_arg;
467
+ int *sizep = (int*)cb_arg;
454
468
 
455
469
  *sizep += (int)RSTRING_LEN(v);
456
470
 
@@ -459,7 +473,7 @@ body_len_cb(VALUE v, VALUE cb_arg, int argc, const VALUE *argv, VALUE blockarg)
459
473
 
460
474
  static VALUE
461
475
  body_append_cb(VALUE v, VALUE cb_arg, int argc, const VALUE *argv, VALUE blockarg) {
462
- agooText *tp = (agooText*)cb_arg;
476
+ agooText *tp = (agooText*)cb_arg;
463
477
 
464
478
  *tp = agoo_text_append(*tp, StringValuePtr(v), (int)RSTRING_LEN(v));
465
479
 
@@ -468,81 +482,81 @@ body_append_cb(VALUE v, VALUE cb_arg, int argc, const VALUE *argv, VALUE blockar
468
482
 
469
483
  static VALUE
470
484
  handle_rack_inner(VALUE x) {
471
- agooReq req = (agooReq)x;
472
- agooText t;
473
- volatile VALUE env = request_env(req, request_wrap(req));
474
- volatile VALUE res = Qnil;
475
- volatile VALUE hv;
476
- volatile VALUE bv;
477
- int code;
478
- const char *status_msg;
479
- int bsize = 0;
485
+ agooReq req = (agooReq)x;
486
+ agooText t;
487
+ volatile VALUE env = request_env(req, request_wrap(req));
488
+ volatile VALUE res = Qnil;
489
+ volatile VALUE hv;
490
+ volatile VALUE bv;
491
+ int code;
492
+ const char *status_msg;
493
+ int bsize = 0;
480
494
 
481
495
  if (NULL == req->hook) {
482
- return Qfalse;
496
+ return Qfalse;
483
497
  }
484
498
  res = rb_funcall((VALUE)req->hook->handler, call_id, 1, env);
485
499
  if (req->res->con->hijacked) {
486
- agoo_queue_wakeup(&agoo_server.con_queue);
487
- return Qfalse;
500
+ agoo_queue_wakeup(&agoo_server.con_queue);
501
+ return Qfalse;
488
502
  }
489
503
  rb_check_type(res, T_ARRAY);
490
504
  if (3 != RARRAY_LEN(res)) {
491
- rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
505
+ rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
492
506
  }
493
507
  hv = rb_ary_entry(res, 0);
494
508
  if (RUBY_T_FIXNUM == rb_type(hv)) {
495
- code = NUM2INT(hv);
509
+ code = NUM2INT(hv);
496
510
  } else {
497
- code = NUM2INT(rb_funcall(hv, to_i_id, 0));
511
+ code = NUM2INT(rb_funcall(hv, to_i_id, 0));
498
512
  }
499
513
  status_msg = agoo_http_code_message(code);
500
514
  if ('\0' == *status_msg) {
501
- rb_raise(rb_eArgError, "invalid rack call() response status code (%d).", code);
515
+ rb_raise(rb_eArgError, "invalid rack call() response status code (%d).", code);
502
516
  }
503
517
  hv = rb_ary_entry(res, 1);
504
518
  if (!rb_respond_to(hv, each_id)) {
505
- rb_raise(rb_eArgError, "invalid rack call() response headers does not respond to each.");
519
+ rb_raise(rb_eArgError, "invalid rack call() response headers does not respond to each.");
506
520
  }
507
521
  bv = rb_ary_entry(res, 2);
508
522
  if (!rb_respond_to(bv, each_id)) {
509
- rb_raise(rb_eArgError, "invalid rack call() response body does not respond to each.");
523
+ rb_raise(rb_eArgError, "invalid rack call() response body does not respond to each.");
510
524
  }
511
525
  if (NULL == (t = agoo_text_allocate(1024))) {
512
- rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
526
+ rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
513
527
  }
514
528
  if (T_ARRAY == rb_type(bv)) {
515
- int i;
516
- int bcnt = (int)RARRAY_LEN(bv);
529
+ int i;
530
+ int bcnt = (int)RARRAY_LEN(bv);
517
531
 
518
- for (i = 0; i < bcnt; i++) {
519
- bsize += (int)RSTRING_LEN(rb_ary_entry(bv, i));
520
- }
532
+ for (i = 0; i < bcnt; i++) {
533
+ bsize += (int)RSTRING_LEN(rb_ary_entry(bv, i));
534
+ }
521
535
  } else {
522
- if (AGOO_HEAD == req->method) {
523
- // Rack wraps the response in two layers, Rack::Lint and
524
- // Rack::BodyProxy. It each is called on either with the HEAD
525
- // method an exception is raised so the length can not be
526
- // determined. This digs down to get the actual response so the
527
- // length can be calculated. A very special case.
528
- if (0 == strcmp("Rack::BodyProxy", rb_obj_classname(bv))) {
529
- volatile VALUE body = rb_ivar_get(bv, rb_intern("@body"));
530
-
531
- if (Qnil != body) {
532
- body = rb_ivar_get(body, rb_intern("@body"));
533
- }
534
- if (Qnil != body) {
535
- body = rb_ivar_get(body, rb_intern("@body"));
536
- }
537
- if (rb_respond_to(body, each_id)) {
538
- rb_block_call(body, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
539
- }
540
- } else {
541
- rb_block_call(bv, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
542
- }
543
- } else {
544
- rb_block_call(bv, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
545
- }
536
+ if (AGOO_HEAD == req->method) {
537
+ // Rack wraps the response in two layers, Rack::Lint and
538
+ // Rack::BodyProxy. It each is called on either with the HEAD
539
+ // method an exception is raised so the length can not be
540
+ // determined. This digs down to get the actual response so the
541
+ // length can be calculated. A very special case.
542
+ if (0 == strcmp("Rack::BodyProxy", rb_obj_classname(bv))) {
543
+ volatile VALUE body = rb_ivar_get(bv, rb_intern("@body"));
544
+
545
+ if (Qnil != body) {
546
+ body = rb_ivar_get(body, rb_intern("@body"));
547
+ }
548
+ if (Qnil != body) {
549
+ body = rb_ivar_get(body, rb_intern("@body"));
550
+ }
551
+ if (rb_respond_to(body, each_id)) {
552
+ rb_block_call(body, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
553
+ }
554
+ } else {
555
+ rb_block_call(bv, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
556
+ }
557
+ } else {
558
+ rb_block_call(bv, each_id, 0, 0, body_len_cb, (VALUE)&bsize);
559
+ }
546
560
  }
547
561
  switch (code) {
548
562
  case 100:
@@ -551,70 +565,70 @@ handle_rack_inner(VALUE x) {
551
565
  case 204:
552
566
  case 205:
553
567
  case 304:
554
- // Content-Type and Content-Length can not be present
555
- t->len = snprintf(t->text, 1024, "HTTP/1.1 %d %s\r\n", code, status_msg);
556
- break;
568
+ // Content-Type and Content-Length can not be present
569
+ t->len = snprintf(t->text, 1024, "HTTP/1.1 %d %s\r\n", code, status_msg);
570
+ break;
557
571
  default:
558
- // Note that using simply sprintf causes an abort with travis OSX tests.
559
- t->len = snprintf(t->text, 1024, "HTTP/1.1 %d %s\r\nContent-Length: %d\r\n", code, status_msg, bsize);
560
- break;
572
+ // Note that using simply sprintf causes an abort with travis OSX tests.
573
+ t->len = snprintf(t->text, 1024, "HTTP/1.1 %d %s\r\nContent-Length: %d\r\n", code, status_msg, bsize);
574
+ break;
561
575
  }
562
576
  if (code < 300) {
563
- VALUE handler = Qnil;
564
-
565
- switch (req->upgrade) {
566
- case AGOO_UP_WS:
567
- if (AGOO_CON_WS != req->res->con_kind ||
568
- Qnil == (handler = rb_hash_lookup(env, push_env_key))) {
569
- strcpy(t->text, err500);
570
- t->len = sizeof(err500) - 1;
571
- break;
572
- }
573
- req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
574
- rupgraded_create(req->res->con, handler, request_env(req, Qnil));
575
- t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
576
- t = agoo_ws_add_headers(req, t);
577
- break;
578
- case AGOO_UP_SSE:
579
- if (AGOO_CON_SSE != req->res->con_kind ||
580
- Qnil == (handler = rb_hash_lookup(env, push_env_key))) {
581
- strcpy(t->text, err500);
582
- t->len = sizeof(err500) - 1;
583
- break;
584
- }
585
- req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
586
- rupgraded_create(req->res->con, handler, request_env(req, Qnil));
587
- t = agoo_sse_upgrade(req, t);
588
- agoo_res_message_push(req->res, t);
589
- agoo_queue_wakeup(&agoo_server.con_queue);
590
- return Qfalse;
591
- default:
592
- break;
593
- }
577
+ VALUE handler = Qnil;
578
+
579
+ switch (req->upgrade) {
580
+ case AGOO_UP_WS:
581
+ if (AGOO_CON_WS != req->res->con_kind ||
582
+ Qnil == (handler = rb_hash_lookup(env, push_env_key))) {
583
+ strcpy(t->text, err500);
584
+ t->len = sizeof(err500) - 1;
585
+ break;
586
+ }
587
+ req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
588
+ rupgraded_create(req->res->con, handler, request_env(req, Qnil));
589
+ t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
590
+ t = agoo_ws_add_headers(req, t);
591
+ break;
592
+ case AGOO_UP_SSE:
593
+ if (AGOO_CON_SSE != req->res->con_kind ||
594
+ Qnil == (handler = rb_hash_lookup(env, push_env_key))) {
595
+ strcpy(t->text, err500);
596
+ t->len = sizeof(err500) - 1;
597
+ break;
598
+ }
599
+ req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
600
+ rupgraded_create(req->res->con, handler, request_env(req, Qnil));
601
+ t = agoo_sse_upgrade(req, t);
602
+ agoo_res_message_push(req->res, t);
603
+ agoo_queue_wakeup(&agoo_server.con_queue);
604
+ return Qfalse;
605
+ default:
606
+ break;
607
+ }
594
608
  }
595
609
  if (AGOO_HEAD == req->method) {
596
- bsize = 0;
610
+ bsize = 0;
597
611
  } else {
598
- if (T_HASH == rb_type(hv)) {
599
- rb_hash_foreach(hv, header_cb, (VALUE)&t);
600
- } else {
601
- rb_block_call(hv, each_id, 0, 0, header_each_cb, (VALUE)&t);
602
- }
612
+ if (T_HASH == rb_type(hv)) {
613
+ rb_hash_foreach(hv, header_cb, (VALUE)&t);
614
+ } else {
615
+ rb_block_call(hv, each_id, 0, 0, header_each_cb, (VALUE)&t);
616
+ }
603
617
  }
604
618
  t = agoo_text_append(t, "\r\n", 2);
605
619
  if (0 < bsize) {
606
- if (T_ARRAY == rb_type(bv)) {
607
- VALUE v;
608
- int i;
609
- int bcnt = (int)RARRAY_LEN(bv);
610
-
611
- for (i = 0; i < bcnt; i++) {
612
- v = rb_ary_entry(bv, i);
613
- t = agoo_text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
614
- }
615
- } else {
616
- rb_block_call(bv, each_id, 0, 0, body_append_cb, (VALUE)&t);
617
- }
620
+ if (T_ARRAY == rb_type(bv)) {
621
+ VALUE v;
622
+ int i;
623
+ int bcnt = (int)RARRAY_LEN(bv);
624
+
625
+ for (i = 0; i < bcnt; i++) {
626
+ v = rb_ary_entry(bv, i);
627
+ t = agoo_text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
628
+ }
629
+ } else {
630
+ rb_block_call(bv, each_id, 0, 0, body_append_cb, (VALUE)&t);
631
+ }
618
632
  }
619
633
  agoo_res_message_push(req->res, t);
620
634
  agoo_queue_wakeup(&agoo_server.con_queue);
@@ -634,12 +648,12 @@ handle_rack(void *x) {
634
648
 
635
649
  static VALUE
636
650
  handle_wab_inner(VALUE x) {
637
- agooReq req = (agooReq)x;
638
- volatile VALUE rr = request_wrap(req);
639
- volatile VALUE rres = response_new();
651
+ agooReq req = (agooReq)x;
652
+ volatile VALUE rr = request_wrap(req);
653
+ volatile VALUE rres = response_new();
640
654
 
641
655
  if (NULL != req->hook) {
642
- rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
656
+ rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
643
657
  }
644
658
  DATA_PTR(rr) = NULL;
645
659
  agoo_res_message_push(req->res, response_text(rres));
@@ -657,49 +671,49 @@ handle_wab(void *x) {
657
671
 
658
672
  static VALUE
659
673
  handle_push_inner(VALUE x) {
660
- agooReq req = (agooReq)x;
674
+ agooReq req = (agooReq)x;
661
675
 
662
676
  switch (req->method) {
663
677
  case AGOO_ON_MSG:
664
- if (req->up->on_msg && NULL != req->hook) {
665
- rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rb_str_new(req->msg, req->mlen));
666
- }
667
- break;
678
+ if (req->up->on_msg && NULL != req->hook) {
679
+ rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rb_str_new(req->msg, req->mlen));
680
+ }
681
+ break;
668
682
  case AGOO_ON_BIN:
669
- if (req->up->on_msg && NULL != req->hook) {
670
- volatile VALUE rstr = rb_str_new(req->msg, req->mlen);
683
+ if (req->up->on_msg && NULL != req->hook) {
684
+ volatile VALUE rstr = rb_str_new(req->msg, req->mlen);
671
685
 
672
- rb_enc_associate(rstr, rb_ascii8bit_encoding());
673
- rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rstr);
674
- }
675
- break;
686
+ rb_enc_associate(rstr, rb_ascii8bit_encoding());
687
+ rb_funcall((VALUE)req->hook->handler, on_message_id, 2, (VALUE)req->up->wrap, rstr);
688
+ }
689
+ break;
676
690
  case AGOO_ON_CLOSE:
677
- agoo_upgraded_ref(req->up);
678
- agoo_server_publish(agoo_pub_close(req->up));
679
- if (req->up->on_close && NULL != req->hook) {
680
- rb_funcall((VALUE)req->hook->handler, on_close_id, 1, (VALUE)req->up->wrap);
681
- }
682
- break;
691
+ agoo_upgraded_ref(req->up);
692
+ agoo_server_publish(agoo_pub_close(req->up));
693
+ if (req->up->on_close && NULL != req->hook) {
694
+ rb_funcall((VALUE)req->hook->handler, on_close_id, 1, (VALUE)req->up->wrap);
695
+ }
696
+ break;
683
697
  case AGOO_ON_SHUTDOWN:
684
- if (NULL != req->hook) {
685
- rb_funcall((VALUE)req->hook->handler, rb_intern("on_shutdown"), 1, (VALUE)req->up->wrap);
686
- }
687
- break;
698
+ if (NULL != req->hook) {
699
+ rb_funcall((VALUE)req->hook->handler, rb_intern("on_shutdown"), 1, (VALUE)req->up->wrap);
700
+ }
701
+ break;
688
702
  case AGOO_ON_ERROR:
689
- if (req->up->on_error && NULL != req->hook) {
690
- volatile VALUE rstr = rb_str_new(req->msg, req->mlen);
703
+ if (req->up->on_error && NULL != req->hook) {
704
+ volatile VALUE rstr = rb_str_new(req->msg, req->mlen);
691
705
 
692
- rb_enc_associate(rstr, rb_ascii8bit_encoding());
693
- rb_funcall((VALUE)req->hook->handler, on_error_id, 2, (VALUE)req->up->wrap, rstr);
694
- }
695
- break;
706
+ rb_enc_associate(rstr, rb_ascii8bit_encoding());
707
+ rb_funcall((VALUE)req->hook->handler, on_error_id, 2, (VALUE)req->up->wrap, rstr);
708
+ }
709
+ break;
696
710
  case AGOO_ON_EMPTY:
697
- if (req->up->on_empty && NULL != req->hook) {
698
- rb_funcall((VALUE)req->hook->handler, on_drained_id, 1, (VALUE)req->up->wrap);
699
- }
700
- break;
711
+ if (req->up->on_empty && NULL != req->hook) {
712
+ rb_funcall((VALUE)req->hook->handler, on_drained_id, 1, (VALUE)req->up->wrap);
713
+ }
714
+ break;
701
715
  default:
702
- break;
716
+ break;
703
717
  }
704
718
  agoo_upgraded_release(req->up);
705
719
 
@@ -715,69 +729,69 @@ handle_push(void *x) {
715
729
  static void
716
730
  handle_protected(agooReq req, bool gvi) {
717
731
  if (NULL == req->hook) {
718
- return;
732
+ return;
719
733
  }
720
734
  switch (req->hook->type) {
721
735
  case BASE_HOOK:
722
- if (gvi) {
723
- rb_thread_call_with_gvl(handle_base, req);
724
- } else {
725
- handle_base(req);
726
- }
727
- break;
736
+ if (gvi) {
737
+ rb_thread_call_with_gvl(handle_base, req);
738
+ } else {
739
+ handle_base(req);
740
+ }
741
+ break;
728
742
  case RACK_HOOK:
729
- if (gvi) {
730
- rb_thread_call_with_gvl(handle_rack, req);
731
- } else {
732
- handle_rack(req);
733
- }
734
- break;
743
+ if (gvi) {
744
+ rb_thread_call_with_gvl(handle_rack, req);
745
+ } else {
746
+ handle_rack(req);
747
+ }
748
+ break;
735
749
  case WAB_HOOK:
736
- if (gvi) {
737
- rb_thread_call_with_gvl(handle_wab, req);
738
- } else {
739
- handle_wab(req);
740
- }
741
- break;
750
+ if (gvi) {
751
+ rb_thread_call_with_gvl(handle_wab, req);
752
+ } else {
753
+ handle_wab(req);
754
+ }
755
+ break;
742
756
  case PUSH_HOOK:
743
- if (gvi) {
744
- rb_thread_call_with_gvl(handle_push, req);
745
- } else {
746
- handle_push(req);
747
- }
748
- break;
757
+ if (gvi) {
758
+ rb_thread_call_with_gvl(handle_push, req);
759
+ } else {
760
+ handle_push(req);
761
+ }
762
+ break;
749
763
  case FUNC_HOOK:
750
- req->hook->func(req);
751
- agoo_queue_wakeup(&agoo_server.con_queue);
752
- break;
764
+ req->hook->func(req);
765
+ agoo_queue_wakeup(&agoo_server.con_queue);
766
+ break;
753
767
  default: {
754
- char buf[256];
755
- int cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n");
756
- agooText message = agoo_text_create(buf, cnt);
757
-
758
- req->res->close = true;
759
- agoo_res_message_push(req->res, message);
760
- agoo_queue_wakeup(&agoo_server.con_queue);
761
- break;
768
+ char buf[256];
769
+ int cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n");
770
+ agooText message = agoo_text_create(buf, cnt);
771
+
772
+ req->res->close = true;
773
+ agoo_res_message_push(req->res, message);
774
+ agoo_queue_wakeup(&agoo_server.con_queue);
775
+ break;
762
776
  }
763
777
  }
764
778
  }
765
779
 
766
780
  static void*
767
781
  process_loop(void *ptr) {
768
- agooReq req;
782
+ agooReq req;
769
783
 
770
784
  atomic_fetch_add(&agoo_server.running, 1);
771
785
  while (agoo_server.active) {
772
- if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, poll_timeout))) {
773
- handle_protected(req, true);
774
- agoo_req_destroy(req);
775
- }
776
- if (agoo_stop) {
777
- agoo_shutdown();
778
- break;
779
- }
780
- agoo_queue_wakeup(&agoo_server.con_queue); // TBD remove if it doesn't speed up the response time
786
+ if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, poll_timeout))) {
787
+ handle_protected(req, true);
788
+ agoo_req_destroy(req);
789
+ }
790
+ if (agoo_stop) {
791
+ agoo_shutdown();
792
+ break;
793
+ }
794
+ agoo_queue_wakeup(&agoo_server.con_queue); // TBD remove if it doesn't speed up the response time
781
795
  }
782
796
  atomic_fetch_sub(&agoo_server.running, 1);
783
797
 
@@ -798,84 +812,96 @@ wrap_process_loop(void *ptr) {
798
812
  */
799
813
  static VALUE
800
814
  rserver_start(VALUE self) {
801
- VALUE *vp;
802
- int i;
803
- int pid;
804
- double giveup;
805
- struct _agooErr err = AGOO_ERR_INIT;
806
- VALUE agoo = rb_const_get_at(rb_cObject, rb_intern("Agoo"));
807
- VALUE v = rb_const_get_at(agoo, rb_intern("VERSION"));
815
+ VALUE *vp;
816
+ int i;
817
+ int pid;
818
+ double giveup;
819
+ struct _agooErr err = AGOO_ERR_INIT;
820
+ VALUE agoo = rb_const_get_at(rb_cObject, rb_intern("Agoo"));
821
+ VALUE v = rb_const_get_at(agoo, rb_intern("VERSION"));
822
+ ID after = rb_intern("after");
808
823
 
809
824
  *the_rserver.worker_pids = getpid();
810
825
 
811
826
  // If workers then set the loop_max based on the expected number of
812
827
  // threads per worker.
813
828
  if (1 < the_rserver.worker_cnt) {
814
- agoo_server.loop_max /= the_rserver.worker_cnt;
815
- if (agoo_server.loop_max < 1) {
816
- agoo_server.loop_max = 1;
817
- }
829
+ agoo_server.loop_max /= the_rserver.worker_cnt;
830
+ if (agoo_server.loop_max < 1) {
831
+ agoo_server.loop_max = 1;
832
+ }
818
833
  }
819
834
  if (AGOO_ERR_OK != setup_listen(&err)) {
820
- rb_raise(rb_eIOError, "%s", err.msg);
835
+ rb_raise(rb_eIOError, "%s", err.msg);
821
836
  }
837
+ if (1 < the_rserver.worker_cnt && the_rserver.forker != Qnil) {
838
+ ID before = rb_intern("before");
839
+
840
+ if (rb_respond_to(the_rserver.forker, before)) {
841
+ rb_funcall(the_rserver.forker, before, 0);
842
+ }
843
+ }
822
844
  for (i = 1; i < the_rserver.worker_cnt; i++) {
823
- VALUE rpid = rb_funcall(rb_cObject, rb_intern("fork"), 0);
824
-
825
- if (Qnil == rpid) {
826
- pid = 0;
827
- } else {
828
- pid = NUM2INT(rpid);
829
- }
830
- if (0 > pid) { // error, use single process
831
- agoo_log_cat(&agoo_error_cat, "Failed to fork. %s.", strerror(errno));
832
- break;
833
- } else if (0 == pid) {
834
- if (AGOO_ERR_OK != agoo_log_start(&err, true)) {
835
- rb_raise(rb_eStandardError, "%s", err.msg);
836
- }
837
- break;
838
- } else {
839
- the_rserver.worker_pids[i] = pid;
840
- }
845
+ VALUE rpid = rb_funcall(rb_cObject, rb_intern("fork"), 0);
846
+
847
+ if (Qnil == rpid) {
848
+ pid = 0;
849
+ } else {
850
+ pid = NUM2INT(rpid);
851
+ }
852
+ if (0 > pid) { // error, use single process
853
+ agoo_log_cat(&agoo_error_cat, "Failed to fork. %s.", strerror(errno));
854
+ break;
855
+ } else if (0 == pid) {
856
+ if (AGOO_ERR_OK != agoo_log_start(&err, true)) {
857
+ rb_raise(rb_eStandardError, "%s", err.msg);
858
+ }
859
+ break;
860
+ } else {
861
+ the_rserver.worker_pids[i] = pid;
862
+ }
841
863
  }
864
+ if (1 < the_rserver.worker_cnt && the_rserver.forker != Qnil && rb_respond_to(the_rserver.forker, after)) {
865
+ rb_funcall(the_rserver.forker, after, 0);
866
+ }
842
867
  if (AGOO_ERR_OK != agoo_server_start(&err, "Agoo", StringValuePtr(v))) {
843
- rb_raise(rb_eStandardError, "%s", err.msg);
868
+ rb_raise(rb_eStandardError, "%s", err.msg);
844
869
  }
845
870
  if (0 >= agoo_server.thread_cnt) {
846
- agooReq req;
847
-
848
- while (agoo_server.active) {
849
- if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, poll_timeout))) {
850
- handle_protected(req, false);
851
- agoo_req_destroy(req);
852
- } else {
853
- rb_thread_schedule();
854
- }
855
- if (agoo_stop) {
856
- agoo_shutdown();
857
- break;
858
- }
859
- }
871
+ agooReq req;
872
+
873
+ while (agoo_server.active) {
874
+ if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, poll_timeout))) {
875
+ handle_protected(req, false);
876
+ agoo_req_destroy(req);
877
+ } else {
878
+ rb_thread_schedule();
879
+ }
880
+ if (agoo_stop) {
881
+ agoo_shutdown();
882
+ break;
883
+ }
884
+ }
860
885
  } else {
861
- if (NULL == (the_rserver.eval_threads = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * (agoo_server.thread_cnt + 1)))) {
862
- rb_raise(rb_eNoMemError, "Failed to allocate memory for the thread pool.");
863
- }
864
- for (i = agoo_server.thread_cnt, vp = the_rserver.eval_threads; 0 < i; i--, vp++) {
865
- *vp = rb_thread_create(wrap_process_loop, NULL);
866
- }
867
- *vp = Qnil;
868
-
869
- giveup = dtime() + 1.0;
870
- while (dtime() < giveup) {
871
- // The processing threads will not start until this thread
872
- // releases ownership so do that and then see if the threads has
873
- // been started yet.
874
- rb_thread_schedule();
875
- if (2 + agoo_server.thread_cnt <= (long)atomic_load(&agoo_server.running)) {
876
- break;
877
- }
878
- }
886
+ if (NULL == (the_rserver.eval_threads = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * (agoo_server.thread_cnt + 1)))) {
887
+ rb_raise(rb_eNoMemError, "Failed to allocate memory for the thread pool.");
888
+ }
889
+ for (i = agoo_server.thread_cnt, vp = the_rserver.eval_threads; 0 < i; i--, vp++) {
890
+ *vp = rb_thread_create(wrap_process_loop, NULL);
891
+ }
892
+ *vp = Qnil;
893
+
894
+ giveup = dtime() + 1.0;
895
+ while (dtime() < giveup) {
896
+ // The processing threads will not start until this thread
897
+ // releases ownership so do that and then see if the threads have
898
+ // been started yet.
899
+ rb_thread_schedule();
900
+ if (agoo_server.loop_cnt + 1 + agoo_server.thread_cnt <= (long)atomic_load(&agoo_server.running)) {
901
+ break;
902
+ }
903
+ dsleep(0.05);
904
+ }
879
905
  }
880
906
  return Qnil;
881
907
  }
@@ -887,16 +913,16 @@ stop_runners() {
887
913
  // cause a segfault. Instead we set a timeout and wait for the running
888
914
  // counter to drop to zero.
889
915
  if (NULL != the_rserver.eval_threads) {
890
- double timeout = dtime() + 2.0;
891
-
892
- while (dtime() < timeout) {
893
- if (0 >= (long)atomic_load(&agoo_server.running)) {
894
- break;
895
- }
896
- dsleep(0.02);
897
- }
898
- AGOO_FREE(the_rserver.eval_threads);
899
- the_rserver.eval_threads = NULL;
916
+ double timeout = dtime() + 2.0;
917
+
918
+ while (dtime() < timeout) {
919
+ if (0 >= (long)atomic_load(&agoo_server.running)) {
920
+ break;
921
+ }
922
+ dsleep(0.02);
923
+ }
924
+ AGOO_FREE(the_rserver.eval_threads);
925
+ the_rserver.eval_threads = NULL;
900
926
  }
901
927
  }
902
928
 
@@ -909,43 +935,43 @@ stop_runners() {
909
935
  VALUE
910
936
  rserver_shutdown(VALUE self) {
911
937
  if (agoo_server.inited) {
912
- agoo_server_shutdown("Agoo", stop_runners);
913
-
914
- if (1 < the_rserver.worker_cnt && getpid() == *the_rserver.worker_pids) {
915
- int i;
916
- int status;
917
- int exit_cnt = 1;
918
- int j;
919
-
920
- for (i = 1; i < the_rserver.worker_cnt; i++) {
921
- kill(the_rserver.worker_pids[i], SIGKILL);
922
- }
923
- for (j = 0; j < 20; j++) {
924
- for (i = 1; i < the_rserver.worker_cnt; i++) {
925
- if (0 == the_rserver.worker_pids[i]) {
926
- continue;
927
- }
928
- if (0 < waitpid(the_rserver.worker_pids[i], &status, WNOHANG)) {
929
- if (WIFEXITED(status)) {
930
- //printf("exited, status=%d for %d\n", agoo_server.worker_pids[i], WEXITSTATUS(status));
931
- the_rserver.worker_pids[i] = 0;
932
- exit_cnt++;
933
- } else if (WIFSIGNALED(status)) {
934
- //printf("*** killed by signal %d for %d\n", agoo_server.worker_pids[i], WTERMSIG(status));
935
- the_rserver.worker_pids[i] = 0;
936
- exit_cnt++;
937
- }
938
- }
939
- }
940
- if (the_rserver.worker_cnt <= exit_cnt) {
941
- break;
942
- }
943
- dsleep(0.2);
944
- }
945
- if (exit_cnt < the_rserver.worker_cnt) {
946
- printf("*-*-* Some workers did not exit.\n");
947
- }
948
- }
938
+ agoo_server_shutdown("Agoo", stop_runners);
939
+
940
+ if (1 < the_rserver.worker_cnt && getpid() == *the_rserver.worker_pids) {
941
+ int i;
942
+ int status;
943
+ int exit_cnt = 1;
944
+ int j;
945
+
946
+ for (i = 1; i < the_rserver.worker_cnt; i++) {
947
+ kill(the_rserver.worker_pids[i], SIGKILL);
948
+ }
949
+ for (j = 0; j < 20; j++) {
950
+ for (i = 1; i < the_rserver.worker_cnt; i++) {
951
+ if (0 == the_rserver.worker_pids[i]) {
952
+ continue;
953
+ }
954
+ if (0 < waitpid(the_rserver.worker_pids[i], &status, WNOHANG)) {
955
+ if (WIFEXITED(status)) {
956
+ //printf("exited, status=%d for %d\n", agoo_server.worker_pids[i], WEXITSTATUS(status));
957
+ the_rserver.worker_pids[i] = 0;
958
+ exit_cnt++;
959
+ } else if (WIFSIGNALED(status)) {
960
+ //printf("*** killed by signal %d for %d\n", agoo_server.worker_pids[i], WTERMSIG(status));
961
+ the_rserver.worker_pids[i] = 0;
962
+ exit_cnt++;
963
+ }
964
+ }
965
+ }
966
+ if (the_rserver.worker_cnt <= exit_cnt) {
967
+ break;
968
+ }
969
+ dsleep(0.2);
970
+ }
971
+ if (exit_cnt < the_rserver.worker_cnt) {
972
+ printf("*-*-* Some workers did not exit.\n");
973
+ }
974
+ }
949
975
  }
950
976
  return Qnil;
951
977
  }
@@ -960,97 +986,97 @@ rserver_shutdown(VALUE self) {
960
986
  */
961
987
  static VALUE
962
988
  handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
963
- agooHook hook;
964
- agooMethod meth = AGOO_ALL;
965
- const char *pat;
966
- ID static_id = rb_intern("static?");
989
+ agooHook hook;
990
+ agooMethod meth = AGOO_ALL;
991
+ const char *pat;
992
+ ID static_id = rb_intern("static?");
967
993
 
968
994
  rb_check_type(pattern, T_STRING);
969
995
  pat = StringValuePtr(pattern);
970
996
 
971
997
  if (connect_sym == method) {
972
- meth = AGOO_CONNECT;
998
+ meth = AGOO_CONNECT;
973
999
  } else if (delete_sym == method) {
974
- meth = AGOO_DELETE;
1000
+ meth = AGOO_DELETE;
975
1001
  } else if (get_sym == method) {
976
- meth = AGOO_GET;
1002
+ meth = AGOO_GET;
977
1003
  } else if (head_sym == method) {
978
- meth = AGOO_HEAD;
1004
+ meth = AGOO_HEAD;
979
1005
  } else if (options_sym == method) {
980
- meth = AGOO_OPTIONS;
1006
+ meth = AGOO_OPTIONS;
981
1007
  } else if (post_sym == method) {
982
- meth = AGOO_POST;
1008
+ meth = AGOO_POST;
983
1009
  } else if (put_sym == method) {
984
- meth = AGOO_PUT;
1010
+ meth = AGOO_PUT;
985
1011
  } else if (patch_sym == method) {
986
- meth = AGOO_PATCH;
1012
+ meth = AGOO_PATCH;
987
1013
  } else if (Qnil == method) {
988
- meth = AGOO_ALL;
1014
+ meth = AGOO_ALL;
989
1015
  } else {
990
- rb_raise(rb_eArgError, "invalid method");
1016
+ rb_raise(rb_eArgError, "invalid method");
991
1017
  }
992
1018
  if (T_STRING == rb_type(handler)) {
993
- handler = resolve_classpath(StringValuePtr(handler), RSTRING_LEN(handler));
1019
+ handler = resolve_classpath(StringValuePtr(handler), RSTRING_LEN(handler));
994
1020
  }
995
1021
  if (rb_respond_to(handler, static_id)) {
996
- if (Qtrue == rb_funcall(handler, static_id, 0)) {
997
- VALUE res = rb_funcall(handler, call_id, 1, Qnil);
998
- VALUE bv;
999
-
1000
- rb_check_type(res, T_ARRAY);
1001
- if (3 != RARRAY_LEN(res)) {
1002
- rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
1003
- }
1004
- bv = rb_ary_entry(res, 2);
1005
- if (T_ARRAY == rb_type(bv)) {
1006
- int i;
1007
- int bcnt = (int)RARRAY_LEN(bv);
1008
- agooText t = agoo_text_allocate(1024);
1009
- struct _agooErr err = AGOO_ERR_INIT;
1010
- VALUE v;
1011
-
1012
- if (NULL == t) {
1013
- rb_raise(rb_eArgError, "failed to allocate response.");
1014
- }
1015
- for (i = 0; i < bcnt; i++) {
1016
- v = rb_ary_entry(bv, i);
1017
- t = agoo_text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
1018
- }
1019
- if (NULL == t) {
1020
- rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
1021
- }
1022
- if (NULL == agoo_page_immutable(&err, pat, t->text, (int)t->len)) {
1023
- rb_raise(rb_eArgError, "%s", err.msg);
1024
- }
1025
- agoo_text_release(t);
1026
-
1027
- return Qnil;
1028
- }
1029
- }
1022
+ if (Qtrue == rb_funcall(handler, static_id, 0)) {
1023
+ VALUE res = rb_funcall(handler, call_id, 1, Qnil);
1024
+ VALUE bv;
1025
+
1026
+ rb_check_type(res, T_ARRAY);
1027
+ if (3 != RARRAY_LEN(res)) {
1028
+ rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
1029
+ }
1030
+ bv = rb_ary_entry(res, 2);
1031
+ if (T_ARRAY == rb_type(bv)) {
1032
+ int i;
1033
+ int bcnt = (int)RARRAY_LEN(bv);
1034
+ agooText t = agoo_text_allocate(1024);
1035
+ struct _agooErr err = AGOO_ERR_INIT;
1036
+ VALUE v;
1037
+
1038
+ if (NULL == t) {
1039
+ rb_raise(rb_eArgError, "failed to allocate response.");
1040
+ }
1041
+ for (i = 0; i < bcnt; i++) {
1042
+ v = rb_ary_entry(bv, i);
1043
+ t = agoo_text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
1044
+ }
1045
+ if (NULL == t) {
1046
+ rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
1047
+ }
1048
+ if (NULL == agoo_page_immutable(&err, pat, t->text, (int)t->len)) {
1049
+ rb_raise(rb_eArgError, "%s", err.msg);
1050
+ }
1051
+ agoo_text_release(t);
1052
+
1053
+ return Qnil;
1054
+ }
1055
+ }
1030
1056
  }
1031
1057
  if (NULL != the_rserver.uses) {
1032
- RUse u;
1058
+ RUse u;
1033
1059
 
1034
- for (u = the_rserver.uses; NULL != u; u = u->next) {
1035
- u->argv[0] = handler;
1036
- handler = rb_funcall2(u->clas, rb_intern("new"), u->argc, u->argv);
1037
- }
1060
+ for (u = the_rserver.uses; NULL != u; u = u->next) {
1061
+ u->argv[0] = handler;
1062
+ handler = rb_funcall2(u->clas, rb_intern("new"), u->argc, u->argv);
1063
+ }
1038
1064
  }
1039
1065
  if (NULL == (hook = rhook_create(meth, pat, handler, &agoo_server.eval_queue))) {
1040
- rb_raise(rb_eStandardError, "out of memory.");
1066
+ rb_raise(rb_eStandardError, "out of memory.");
1041
1067
  } else {
1042
- agooHook h;
1043
- agooHook prev = NULL;
1044
-
1045
- for (h = agoo_server.hooks; NULL != h; h = h->next) {
1046
- prev = h;
1047
- }
1048
- if (NULL != prev) {
1049
- prev->next = hook;
1050
- } else {
1051
- agoo_server.hooks = hook;
1052
- }
1053
- rb_gc_register_address((VALUE*)&hook->handler);
1068
+ agooHook h;
1069
+ agooHook prev = NULL;
1070
+
1071
+ for (h = agoo_server.hooks; NULL != h; h = h->next) {
1072
+ prev = h;
1073
+ }
1074
+ if (NULL != prev) {
1075
+ prev->next = hook;
1076
+ } else {
1077
+ agoo_server.hooks = hook;
1078
+ }
1079
+ rb_gc_register_address((VALUE*)&hook->handler);
1054
1080
  }
1055
1081
  return Qnil;
1056
1082
  }
@@ -1065,7 +1091,7 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
1065
1091
  static VALUE
1066
1092
  handle_not_found(VALUE self, VALUE handler) {
1067
1093
  if (NULL == (agoo_server.hook404 = rhook_create(AGOO_GET, "/", handler, &agoo_server.eval_queue))) {
1068
- rb_raise(rb_eStandardError, "out of memory.");
1094
+ rb_raise(rb_eStandardError, "out of memory.");
1069
1095
  }
1070
1096
  rb_gc_register_address((VALUE*)&agoo_server.hook404->handler);
1071
1097
 
@@ -1081,10 +1107,10 @@ handle_not_found(VALUE self, VALUE handler) {
1081
1107
  */
1082
1108
  static VALUE
1083
1109
  add_mime(VALUE self, VALUE suffix, VALUE type) {
1084
- struct _agooErr err = AGOO_ERR_INIT;
1110
+ struct _agooErr err = AGOO_ERR_INIT;
1085
1111
 
1086
1112
  if (AGOO_ERR_OK != mime_set(&err, StringValuePtr(suffix), StringValuePtr(type))) {
1087
- rb_raise(rb_eArgError, "%s", err.msg);
1113
+ rb_raise(rb_eArgError, "%s", err.msg);
1088
1114
  }
1089
1115
  return Qnil;
1090
1116
  }
@@ -1099,26 +1125,26 @@ add_mime(VALUE self, VALUE suffix, VALUE type) {
1099
1125
  */
1100
1126
  static VALUE
1101
1127
  path_group(VALUE self, VALUE path, VALUE dirs) {
1102
- struct _agooErr err = AGOO_ERR_INIT;
1103
- agooGroup g;
1128
+ struct _agooErr err = AGOO_ERR_INIT;
1129
+ agooGroup g;
1104
1130
 
1105
1131
  rb_check_type(path, T_STRING);
1106
1132
  rb_check_type(dirs, T_ARRAY);
1107
1133
 
1108
1134
  if (NULL != (g = agoo_group_create(StringValuePtr(path)))) {
1109
- int i;
1110
- int dcnt = (int)RARRAY_LEN(dirs);
1111
- VALUE entry;
1112
-
1113
- for (i = dcnt - 1; 0 <= i; i--) {
1114
- entry = rb_ary_entry(dirs, i);
1115
- if (T_STRING != rb_type(entry)) {
1116
- entry = rb_funcall(entry, rb_intern("to_s"), 0);
1117
- }
1118
- if (NULL == agoo_group_add(&err, g, StringValuePtr(entry))) {
1119
- rb_raise(rb_eStandardError, "%s", err.msg);
1120
- }
1121
- }
1135
+ int i;
1136
+ int dcnt = (int)RARRAY_LEN(dirs);
1137
+ VALUE entry;
1138
+
1139
+ for (i = dcnt - 1; 0 <= i; i--) {
1140
+ entry = rb_ary_entry(dirs, i);
1141
+ if (T_STRING != rb_type(entry)) {
1142
+ entry = rb_funcall(entry, rb_intern("to_s"), 0);
1143
+ }
1144
+ if (NULL == agoo_group_add(&err, g, StringValuePtr(entry))) {
1145
+ rb_raise(rb_eStandardError, "%s", err.msg);
1146
+ }
1147
+ }
1122
1148
  }
1123
1149
  return Qnil;
1124
1150
  }
@@ -1141,7 +1167,7 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
1141
1167
  */
1142
1168
  static VALUE
1143
1169
  header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
1144
- struct _agooErr err = AGOO_ERR_INIT;
1170
+ struct _agooErr err = AGOO_ERR_INIT;
1145
1171
 
1146
1172
  rb_check_type(path, T_STRING);
1147
1173
  rb_check_type(mime, T_STRING);
@@ -1149,7 +1175,7 @@ header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
1149
1175
  rb_check_type(value, T_STRING);
1150
1176
 
1151
1177
  if (AGOO_ERR_OK != agoo_header_rule(&err, StringValuePtr(path), StringValuePtr(mime), StringValuePtr(key), StringValuePtr(value))) {
1152
- rb_raise(rb_eArgError, "%s", err.msg);
1178
+ rb_raise(rb_eArgError, "%s", err.msg);
1153
1179
  }
1154
1180
  return Qnil;
1155
1181
  }
@@ -1166,32 +1192,32 @@ header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
1166
1192
  */
1167
1193
  static VALUE
1168
1194
  domain(VALUE self, VALUE host, VALUE path) {
1169
- struct _agooErr err = AGOO_ERR_INIT;
1195
+ struct _agooErr err = AGOO_ERR_INIT;
1170
1196
 
1171
1197
  switch(rb_type(host)) {
1172
1198
  case RUBY_T_STRING:
1173
- rb_check_type(path, T_STRING);
1174
- if (AGOO_ERR_OK != agoo_domain_add(&err, rb_string_value_ptr((VALUE*)&host), rb_string_value_ptr((VALUE*)&path))) {
1175
- rb_raise(rb_eArgError, "%s", err.msg);
1176
- }
1177
- break;
1199
+ rb_check_type(path, T_STRING);
1200
+ if (AGOO_ERR_OK != agoo_domain_add(&err, rb_string_value_ptr((VALUE*)&host), rb_string_value_ptr((VALUE*)&path))) {
1201
+ rb_raise(rb_eArgError, "%s", err.msg);
1202
+ }
1203
+ break;
1178
1204
  case RUBY_T_REGEXP: {
1179
- volatile VALUE v = rb_funcall(host, rb_intern("inspect"), 0);
1180
- char rx[1024];
1181
-
1182
- if (sizeof(rx) <= (size_t)RSTRING_LEN(v)) {
1183
- rb_raise(rb_eArgError, "host Regex limited to %ld characters", sizeof(rx));
1184
- }
1185
- strcpy(rx, rb_string_value_ptr((VALUE*)&v) + 1);
1186
- rx[RSTRING_LEN(v) - 2] = '\0';
1187
- if (AGOO_ERR_OK != agoo_domain_add_regex(&err, rx, rb_string_value_ptr((VALUE*)&path))) {
1188
- rb_raise(rb_eArgError, "%s", err.msg);
1189
- }
1190
- break;
1205
+ volatile VALUE v = rb_funcall(host, rb_intern("inspect"), 0);
1206
+ char rx[1024];
1207
+
1208
+ if (sizeof(rx) <= (size_t)RSTRING_LEN(v)) {
1209
+ rb_raise(rb_eArgError, "host Regex limited to %ld characters", sizeof(rx));
1210
+ }
1211
+ strcpy(rx, rb_string_value_ptr((VALUE*)&v) + 1);
1212
+ rx[RSTRING_LEN(v) - 2] = '\0';
1213
+ if (AGOO_ERR_OK != agoo_domain_add_regex(&err, rx, rb_string_value_ptr((VALUE*)&path))) {
1214
+ rb_raise(rb_eArgError, "%s", err.msg);
1215
+ }
1216
+ break;
1191
1217
  }
1192
1218
  default:
1193
- rb_raise(rb_eArgError, "host must be a String or Regex");
1194
- break;
1219
+ rb_raise(rb_eArgError, "host must be a String or Regex");
1220
+ break;
1195
1221
  }
1196
1222
  return Qnil;
1197
1223
  }
@@ -1206,13 +1232,13 @@ domain(VALUE self, VALUE host, VALUE path) {
1206
1232
  static VALUE
1207
1233
  rack_early_hints(VALUE self, VALUE on) {
1208
1234
  if (Qtrue == on) {
1209
- agoo_server.rack_early_hints = true;
1235
+ agoo_server.rack_early_hints = true;
1210
1236
  } else if (Qfalse == on) {
1211
- agoo_server.rack_early_hints = false;
1237
+ agoo_server.rack_early_hints = false;
1212
1238
  } else if (Qnil == on) {
1213
- on = agoo_server.rack_early_hints ? Qtrue : Qfalse;
1239
+ on = agoo_server.rack_early_hints ? Qtrue : Qfalse;
1214
1240
  } else {
1215
- rb_raise(rb_eArgError, "rack_early_hints can only be set to true or false");
1241
+ rb_raise(rb_eArgError, "rack_early_hints can only be set to true or false");
1216
1242
  }
1217
1243
  return on;
1218
1244
  }
@@ -1226,23 +1252,23 @@ rack_early_hints(VALUE self, VALUE on) {
1226
1252
  */
1227
1253
  static VALUE
1228
1254
  use(int argc, VALUE *argv, VALUE self) {
1229
- VALUE mc;
1230
- RUse u;
1255
+ VALUE mc;
1256
+ RUse u;
1231
1257
 
1232
1258
  if (argc < 1) { // at least the middleware class must be provided.
1233
- rb_raise(rb_eArgError, "no middleware class provided");
1259
+ rb_raise(rb_eArgError, "no middleware class provided");
1234
1260
  }
1235
1261
  mc = argv[0];
1236
1262
  if (T_CLASS != rb_type(mc)) {
1237
- rb_raise(rb_eArgError, "the first argument to use must be a class");
1263
+ rb_raise(rb_eArgError, "the first argument to use must be a class");
1238
1264
  }
1239
1265
  if (NULL == (u = (RUse)AGOO_MALLOC(sizeof(struct _rUse)))) {
1240
- rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
1266
+ rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
1241
1267
  }
1242
1268
  u->clas = mc;
1243
1269
  u->argc = argc;
1244
1270
  if (NULL == (u->argv = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * u->argc))) {
1245
- rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
1271
+ rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
1246
1272
  }
1247
1273
  memcpy(u->argv, argv, argc * sizeof(VALUE));
1248
1274
  u->next = the_rserver.uses;
@@ -1283,16 +1309,16 @@ server_init(VALUE mod) {
1283
1309
  on_request_id = rb_intern("on_request");
1284
1310
  to_i_id = rb_intern("to_i");
1285
1311
 
1286
- connect_sym = ID2SYM(rb_intern("CONNECT")); rb_gc_register_address(&connect_sym);
1287
- delete_sym = ID2SYM(rb_intern("DELETE")); rb_gc_register_address(&delete_sym);
1288
- get_sym = ID2SYM(rb_intern("GET")); rb_gc_register_address(&get_sym);
1289
- head_sym = ID2SYM(rb_intern("HEAD")); rb_gc_register_address(&head_sym);
1290
- options_sym = ID2SYM(rb_intern("OPTIONS")); rb_gc_register_address(&options_sym);
1291
- post_sym = ID2SYM(rb_intern("POST")); rb_gc_register_address(&post_sym);
1292
- put_sym = ID2SYM(rb_intern("PUT")); rb_gc_register_address(&put_sym);
1293
- patch_sym = ID2SYM(rb_intern("PATCH")); rb_gc_register_address(&patch_sym);
1312
+ connect_sym = ID2SYM(rb_intern("CONNECT")); rb_gc_register_address(&connect_sym);
1313
+ delete_sym = ID2SYM(rb_intern("DELETE")); rb_gc_register_address(&delete_sym);
1314
+ get_sym = ID2SYM(rb_intern("GET")); rb_gc_register_address(&get_sym);
1315
+ head_sym = ID2SYM(rb_intern("HEAD")); rb_gc_register_address(&head_sym);
1316
+ options_sym = ID2SYM(rb_intern("OPTIONS")); rb_gc_register_address(&options_sym);
1317
+ post_sym = ID2SYM(rb_intern("POST")); rb_gc_register_address(&post_sym);
1318
+ put_sym = ID2SYM(rb_intern("PUT")); rb_gc_register_address(&put_sym);
1319
+ patch_sym = ID2SYM(rb_intern("PATCH")); rb_gc_register_address(&patch_sym);
1294
1320
 
1295
- push_env_key = rb_str_new_cstr("rack.upgrade"); rb_gc_register_address(&push_env_key);
1321
+ push_env_key = rb_str_new_cstr("rack.upgrade"); rb_gc_register_address(&push_env_key);
1296
1322
 
1297
1323
  rserver = Data_Wrap_Struct(rb_cObject, server_mark, NULL, strdup("dummy"));
1298
1324
  rb_gc_register_address(&rserver);