opal-up 0.0.2 → 0.0.3

data/ext/up_ext/loop_data.h

@@ -0,0 +1,38 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LOOP_DATA_H
+#define LOOP_DATA_H
+
+struct us_internal_loop_data_t {
+    struct us_timer_t *sweep_timer;
+    struct us_internal_async *wakeup_async;
+    int last_write_failed;
+    struct us_socket_context_t *head;
+    struct us_socket_context_t *iterator;
+    char *recv_buf;
+    void *ssl_data;
+    void (*pre_cb)(struct us_loop_t *);
+    void (*post_cb)(struct us_loop_t *);
+    struct us_socket_t *closed_head;
+    struct us_socket_t *low_prio_head;
+    int low_prio_budget;
+    /* We do not care if this flips or not, it doesn't matter */
+    long long iteration_nr;
+};
+
+#endif // LOOP_DATA_H

data/ext/up_ext/socket.c

@@ -0,0 +1,231 @@
+/*
+ * Authored by Alex Hultman, 2018-2021.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBUS_USE_IO_URING
+
+#include "libusockets.h"
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+/* Shared with SSL */
+
+int us_socket_local_port(int ssl, struct us_socket_t *s) {
+    struct bsd_addr_t addr;
+    if (bsd_local_addr(us_poll_fd(&s->p), &addr)) {
+        return -1;
+    } else {
+        return bsd_addr_get_port(&addr);
+    }
+}
+
+int us_socket_remote_port(int ssl, struct us_socket_t *s) {
+    struct bsd_addr_t addr;
+    if (bsd_remote_addr(us_poll_fd(&s->p), &addr)) {
+        return -1;
+    } else {
+        return bsd_addr_get_port(&addr);
+    }
+}
+
+void us_socket_shutdown_read(int ssl, struct us_socket_t *s) {
+    /* This syscall is idempotent so no extra check is needed */
+    bsd_shutdown_socket_read(us_poll_fd((struct us_poll_t *) s));
+}
+
+void us_socket_remote_address(int ssl, struct us_socket_t *s, char *buf, int *length) {
+    struct bsd_addr_t addr;
+    if (bsd_remote_addr(us_poll_fd(&s->p), &addr) || *length < bsd_addr_get_ip_length(&addr)) {
+        *length = 0;
+    } else {
+        *length = bsd_addr_get_ip_length(&addr);
+        memcpy(buf, bsd_addr_get_ip(&addr), *length);
+    }
+}
+
+struct us_socket_context_t *us_socket_context(int ssl, struct us_socket_t *s) {
+    return s->context;
+}
+
+void us_socket_timeout(int ssl, struct us_socket_t *s, unsigned int seconds) {
+    if (seconds) {
+        s->timeout = ((unsigned int)s->context->timestamp + ((seconds + 3) >> 2)) % 240;
+    } else {
+        s->timeout = 255;
+    }
+}
+
+void us_socket_long_timeout(int ssl, struct us_socket_t *s, unsigned int minutes) {
+    if (minutes) {
+        s->long_timeout = ((unsigned int)s->context->long_timestamp + minutes) % 240;
+    } else {
+        s->long_timeout = 255;
+    }
+}
+
+void us_socket_flush(int ssl, struct us_socket_t *s) {
+    if (!us_socket_is_shut_down(0, s)) {
+        bsd_socket_flush(us_poll_fd((struct us_poll_t *) s));
+    }
+}
+
+int us_socket_is_closed(int ssl, struct us_socket_t *s) {
+    return s->prev == (struct us_socket_t *) s->context;
+}
+
+int us_socket_is_established(int ssl, struct us_socket_t *s) {
+    /* Everything that is not POLL_TYPE_SEMI_SOCKET is established */
+    return us_internal_poll_type((struct us_poll_t *) s) != POLL_TYPE_SEMI_SOCKET;
+}
+
+/* Exactly the same as us_socket_close but does not emit on_close event */
+struct us_socket_t *us_socket_close_connecting(int ssl, struct us_socket_t *s) {
+    if (!us_socket_is_closed(0, s)) {
+        us_internal_socket_context_unlink_socket(s->context, s);
+        us_poll_stop((struct us_poll_t *) s, s->context->loop);
+        bsd_close_socket(us_poll_fd((struct us_poll_t *) s));
+
+        /* Link this socket to the close-list and let it be deleted after this iteration */
+        s->next = s->context->loop->data.closed_head;
+        s->context->loop->data.closed_head = s;
+
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
+
+        //return s->context->on_close(s, code, reason);
+    }
+    return s;
+}
+
+/* Same as above but emits on_close */
+struct us_socket_t *us_socket_close(int ssl, struct us_socket_t *s, int code, void *reason) {
+    if (!us_socket_is_closed(0, s)) {
+        if (s->low_prio_state == 1) {
+            /* Unlink this socket from the low-priority queue */
+            if (!s->prev) s->context->loop->data.low_prio_head = s->next;
+            else s->prev->next = s->next;
+
+            if (s->next) s->next->prev = s->prev;
+
+            s->prev = 0;
+            s->next = 0;
+            s->low_prio_state = 0;
+        } else {
+            us_internal_socket_context_unlink_socket(s->context, s);
+        }
+        us_poll_stop((struct us_poll_t *) s, s->context->loop);
+        bsd_close_socket(us_poll_fd((struct us_poll_t *) s));
+
+        /* Link this socket to the close-list and let it be deleted after this iteration */
+        s->next = s->context->loop->data.closed_head;
+        s->context->loop->data.closed_head = s;
+
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
+
+        return s->context->on_close(s, code, reason);
+    }
+    return s;
+}
+
+/* Not shared with SSL */
+
+void *us_socket_get_native_handle(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_get_native_handle((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return (void *) (uintptr_t) us_poll_fd((struct us_poll_t *) s);
+}
+
+/* This is not available for SSL sockets as it makes no sense. */
+int us_socket_write2(int ssl, struct us_socket_t *s, const char *header, int header_length, const char *payload, int payload_length) {
+
+    if (us_socket_is_closed(ssl, s) || us_socket_is_shut_down(ssl, s)) {
+        return 0;
+    }
+
+    int written = bsd_write2(us_poll_fd(&s->p), header, header_length, payload, payload_length);
+    if (written != header_length + payload_length) {
+        us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+    }
+
+    return written < 0 ? 0 : written;
+}
+
+int us_socket_write(int ssl, struct us_socket_t *s, const char *data, int length, int msg_more) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_write((struct us_internal_ssl_socket_t *) s, data, length, msg_more);
+    }
+#endif
+
+    if (us_socket_is_closed(ssl, s) || us_socket_is_shut_down(ssl, s)) {
+        return 0;
+    }
+
+    int written = bsd_send(us_poll_fd(&s->p), data, length, msg_more);
+    if (written != length) {
+        s->context->loop->data.last_write_failed = 1;
+        us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
+    }
+
+    return written < 0 ? 0 : written;
+}
+
+void *us_socket_ext(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_ext((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return s + 1;
+}
+
+int us_socket_is_shut_down(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        return us_internal_ssl_socket_is_shut_down((struct us_internal_ssl_socket_t *) s);
+    }
+#endif
+
+    return us_internal_poll_type(&s->p) == POLL_TYPE_SOCKET_SHUT_DOWN;
+}
+
+void us_socket_shutdown(int ssl, struct us_socket_t *s) {
+#ifndef LIBUS_NO_SSL
+    if (ssl) {
+        us_internal_ssl_socket_shutdown((struct us_internal_ssl_socket_t *) s);
+        return;
+    }
+#endif
+
+    /* Todo: should we emit on_close if calling shutdown on an already half-closed socket?
+     * We need more states in that case, we need to track RECEIVED_FIN
+     * so far, the app has to track this and call close as needed */
+    if (!us_socket_is_closed(ssl, s) && !us_socket_is_shut_down(ssl, s)) {
+        us_internal_poll_set_type(&s->p, POLL_TYPE_SOCKET_SHUT_DOWN);
+        us_poll_change(&s->p, s->context->loop, us_poll_events(&s->p) & LIBUS_SOCKET_READABLE);
+        bsd_shutdown_socket(us_poll_fd((struct us_poll_t *) s));
+    }
+}
+
+#endif

data/ext/up_ext/up_ext.c

@@ -0,0 +1,278 @@
+#include <ruby.h>
+#include <unistd.h>
+#include "libusockets.h"
+#include "libuwebsockets.h"
+
+#define USE_SSL 0
+
+static VALUE mUp;
+static VALUE mRuby;
+static VALUE cServer;
+static VALUE cCluster;
+static VALUE cRackEnv;
+static VALUE cRequest;
+
+static ID id_app;
+static ID id_call;
+static ID id_close;
+static ID id_each;
+static ID id_host;
+static ID id_port;
+
+const rb_data_type_t up_request_t = {.wrap_struct_name = "Up::Ruby::Request",
+                                       .function = {.dmark = NULL,
+                                                    .dfree = NULL,
+                                                    .dsize = NULL,
+                                                    .dcompact = NULL,
+                                                    .reserved = {0}},
+                                       .parent = NULL,
+                                       .data = NULL,
+                                       .flags = 0};
+
+VALUE up_internal_handle_part(RB_BLOCK_CALL_FUNC_ARGLIST(rpart, res)) {
+  Check_Type(rpart, T_STRING);
+  uws_res_write(USE_SSL, (uws_res_t *)res, RSTRING_PTR(rpart), RSTRING_LEN(rpart));
+  return Qnil;
+}
+
+static void up_server_request_handler(uws_res_t *res, uws_req_t *req, void *rapp) {
+  VALUE rreq = TypedData_Wrap_Struct(cRequest, &up_request_t, req);
+  VALUE renv = rb_class_new_instance(1, (const VALUE *)&rreq, cRackEnv);
+  VALUE rres = rb_funcall((VALUE)rapp, id_call, 1, renv);
+  Check_Type(rres, T_ARRAY);
+  VALUE rparts = RARRAY_AREF(rres, 2);
+  VALUE rpart;
+  if (TYPE(rparts) == T_ARRAY) {
+    long i, l = RARRAY_LEN(rparts);
+    for (i = 0; i < l; i++) {
+      rpart = RARRAY_AREF(rparts, i);
+      Check_Type(rpart, T_STRING);
+      uws_res_write(USE_SSL, res, RSTRING_PTR(rpart), RSTRING_LEN(rpart));
+    }
+  } else if (rb_respond_to(rparts, id_each)) {
+    rb_block_call(rparts, id_each, 0, NULL, up_internal_handle_part, (VALUE)res);
+  } else if (rb_respond_to(rparts, id_call)) {
+    rpart = rb_funcall(rparts, id_call, 0);
+    Check_Type(rpart, T_STRING);
+    uws_res_write(USE_SSL, res, RSTRING_PTR(rpart), RSTRING_LEN(rpart));
+  }
+  if (rb_respond_to(rparts, id_close))
+    rb_funcall(rparts, id_close, 0);
+  FIX2INT(RARRAY_PTR(rres)[0]);
+  uws_res_end_without_body(USE_SSL, res, false);
+}
+
+static void up_server_listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data) {
+    if (listen_socket)
+        fprintf(stderr, "Server is running on http://%s:%d\n", config.host, config.port);
+}
+
+static void up_server_t_free(void *p) {
+  if (p)
+    uws_app_destroy(USE_SSL, (uws_app_t *)p);
+}
+
+const rb_data_type_t up_server_t = {.wrap_struct_name = "Up::Ruby::Server",
+                                       .function = {.dmark = NULL,
+                                                    .dfree = up_server_t_free,
+                                                    .dsize = NULL,
+                                                    .dcompact = NULL,
+                                                    .reserved = {0}},
+                                       .parent = NULL,
+                                       .data = NULL,
+                                       .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE up_server_alloc(VALUE rclass) {
+  uws_app_t *app = NULL;
+  return TypedData_Wrap_Struct(rclass, &up_server_t, app);
+}
+
+static void up_internal_check_arg_types(VALUE rapp, VALUE *rhost, VALUE *rport) {
+  if (!rb_respond_to(rapp, id_call))
+    rb_raise(rb_eArgError, "app does not respond to #call");
+  if (*rhost == Qundef || *rhost == Qnil) {
+    *rhost = rb_str_new("localhost", 9);
+  }
+  Check_Type(*rhost, T_STRING);
+  if (*rport == Qundef || *rport == Qnil) {
+    *rport = INT2FIX(3000);
+  }
+  Check_Type(*rport, T_FIXNUM);
+}
+
+static VALUE up_server_init(int argc, VALUE *argv, VALUE self) {
+  if (!rb_keyword_given_p())
+    rb_raise(rb_eArgError, "no args given, must at least provide app:");
+  ID kwargs[] = {id_app, id_host, id_port};
+  VALUE rargs[3] = {Qnil, Qnil, Qnil};
+  VALUE options = Qnil;
+
+  rb_scan_args_kw(1, argc, argv, ":", &options);
+  rb_get_kwargs(options, kwargs, 1, 2, rargs);
+  
+  VALUE rapp = rargs[0];
+  VALUE rhost = rargs[1];
+  VALUE rport = rargs[2];
+
+  up_internal_check_arg_types(rapp, &rhost, &rport);
+
+  rb_ivar_set(self, id_app, rapp);
+  rb_ivar_set(self, id_host, rhost);
+  rb_ivar_set(self, id_port, rport);
+  return self;
+}
+
+static VALUE up_server_listen(VALUE self) {
+  VALUE rapp = rb_ivar_get(self, id_app);
+  VALUE rhost = rb_ivar_get(self, id_host);
+  VALUE rport = rb_ivar_get(self, id_port);
+
+  up_internal_check_arg_types(rapp, &rhost, &rport);
+
+  struct us_socket_context_options_t options = {.key_file_name = NULL, .cert_file_name = NULL, .ca_file_name = NULL,
+                                                .passphrase = NULL, .dh_params_file_name = NULL, .ssl_ciphers = NULL};
+  DATA_PTR(self) = uws_create_app(USE_SSL, options);
+  uws_app_t *app = DATA_PTR(self);
+  if (!app)
+    rb_raise(rb_eRuntimeError, "could not init uws app");
+  uws_app_any(USE_SSL, app, "/*", up_server_request_handler, (void *)rapp);
+  uws_app_listen_config_t config = {.port=3000, .host="localhost", .options=0};
+  uws_app_listen_with_config(USE_SSL, app, config, up_server_listen_handler, NULL);
+  uws_app_run(USE_SSL, app);
+  return Qnil;
+}
+
+static VALUE up_server_stop(VALUE self) {
+  uws_app_t *app = DATA_PTR(self);
+  if (!app)
+    rb_raise(rb_eRuntimeError, "no uws, did initialize call super?");
+  uws_app_close(USE_SSL, app);
+  return Qnil;
+}
+
+static VALUE up_cluster_listen(VALUE self) {
+  VALUE rapp = rb_ivar_get(self, id_app);
+  VALUE rhost = rb_ivar_get(self, id_host);
+  VALUE rport = rb_ivar_get(self, id_port);
+
+  up_internal_check_arg_types(rapp, &rhost, &rport);
+  long i = sysconf(_SC_NPROCESSORS_ONLN);
+  pid_t pid;
+  for (; i > 1; i--) {
+    pid = fork();
+    if (pid > 0) {
+      // do nothing
+    } else if (pid == 0) {
+      struct us_socket_context_options_t options = {.key_file_name = NULL, .cert_file_name = NULL, .ca_file_name = NULL,
+                                                .passphrase = NULL, .dh_params_file_name = NULL, .ssl_ciphers = NULL};
+      DATA_PTR(self) = uws_create_app(USE_SSL, options);
+      uws_app_t *app = DATA_PTR(self);
+      if (!app)
+        rb_raise(rb_eRuntimeError, "could not init uws app");
+      uws_app_any(USE_SSL, app, "/*", up_server_request_handler, (void *)rapp);
+      uws_app_listen_config_t config = {.port=3000, .host="localhost", .options=0};
+      uws_app_listen_with_config(USE_SSL, app, config, up_server_listen_handler, NULL);
+      uws_app_run(USE_SSL, app);
+    }
+  }
+  if (pid > 0) {
+    struct us_socket_context_options_t options = {.key_file_name = NULL, .cert_file_name = NULL, .ca_file_name = NULL,
+                                              .passphrase = NULL, .dh_params_file_name = NULL, .ssl_ciphers = NULL};
+    DATA_PTR(self) = uws_create_app(USE_SSL, options);
+    uws_app_t *app = DATA_PTR(self);
+    if (!app)
+      rb_raise(rb_eRuntimeError, "could not init uws app");
+    uws_app_any(USE_SSL, app, "/*", up_server_request_handler, (void *)rapp);
+    uws_app_listen_config_t config = {.port=3000, .host="localhost", .options=0};
+    uws_app_listen_with_config(USE_SSL, app, config, up_server_listen_handler, NULL);
+    uws_app_run(USE_SSL, app);
+  }
+
+  return Qnil;
+}
+
+static VALUE up_cluster_stop(VALUE self) {
+  // uws_app_t *app = DATA_PTR(self);
+  // uws_app_close(USE_SSL, app);
+  return Qnil;
+}
+
+static VALUE up_request_alloc(VALUE rclass) {
+  return TypedData_Wrap_Struct(rclass, &up_request_t, (uws_req_t*)NULL);
+}
+
+static void up_internal_header_handler(const char *h, size_t h_len, const char *v, size_t v_len, void *rheaders) {
+  rb_hash_aset((VALUE)rheaders, rb_str_new(h, h_len), rb_str_new(v, v_len));
+}
+
+static VALUE up_request_headers(VALUE self) {
+  uws_req_t *req = DATA_PTR(self);
+  if (!req)
+    return Qnil;
+  VALUE rheaders = rb_hash_new();
+  uws_req_for_each_header(req, up_internal_header_handler, (void *)rheaders);
+  return rheaders;
+}
+
+static VALUE up_request_get_header(VALUE self, VALUE rheader) {
+  uws_req_t *req = DATA_PTR(self);
+  if (!req)
+    return Qnil;
+  Check_Type(rheader, T_STRING);
+  const char *header;
+  size_t len = uws_req_get_header(req, RSTRING_PTR(rheader), RSTRING_LEN(rheader), &header);
+  return rb_str_new(header, len);
+}
+
+static VALUE up_request_get_method(VALUE self) {
+  uws_req_t *req = DATA_PTR(self);
+  if (!req)
+    return Qnil;
+  const char *method;
+  size_t len = uws_req_get_method(req, &method);
+  return rb_str_new(method, len);
+}
+
+static VALUE up_request_get_query(VALUE self) {
+  return Qnil;
+}
+
+static VALUE up_request_get_url(VALUE self) {
+  uws_req_t *req = DATA_PTR(self);
+  if (!req)
+    return Qnil;
+  const char *url;
+  size_t len = uws_req_get_url(req, &url);
+  return rb_str_new(url, len);
+}
+
+void Init_up_ext(void) {
+  id_app = rb_intern("app");
+  id_call = rb_intern("call");
+  id_close = rb_intern("close");
+  id_each = rb_intern("each");
+  id_host = rb_intern("host");
+  id_port = rb_intern("port");
+
+  mUp = rb_define_module("Up");
+  mRuby = rb_define_module_under(mUp, "Ruby");
+
+  cServer = rb_define_class_under(mRuby, "Server", rb_cObject);
+  rb_define_alloc_func(cServer, up_server_alloc);
+  rb_define_method(cServer, "initialize", up_server_init, -1);
+  rb_define_method(cServer, "listen", up_server_listen, 0);
+  rb_define_method(cServer, "stop", up_server_stop, 0);
+
+  cCluster = rb_define_class_under(mRuby, "Cluster", cServer);
+  rb_define_method(cCluster, "listen", up_cluster_listen, 0);
+  rb_define_method(cCluster, "stop", up_cluster_stop, 0);
+
+  cRackEnv = rb_define_class_under(mRuby, "RackEnv", rb_cHash);
+  cRequest = rb_define_class_under(mRuby, "Request", rb_cObject);
+  rb_define_alloc_func(cRequest, up_request_alloc);
+  rb_define_method(cRequest, "each_header", up_request_headers, 0);
+  rb_define_method(cRequest, "get_header", up_request_get_header, 1);
+  rb_define_method(cRequest, "get_method", up_request_get_method, 0);
+  rb_define_method(cRequest, "get_query", up_request_get_query, 0);
+  rb_define_method(cRequest, "get_url", up_request_get_url, 0);
+}

data/lib/up/node/rack_env.rb

@@ -46,11 +46,11 @@ module Up
                     when 'rack.url_scheme'
                       @config[:scheme]
                     when 'HTTP_VERSION'
-                      `#@reg.httpVersion`
+                      `#@req.httpVersion`
                     when 'PATH_INFO'
                       `#@req.url`
                     when 'QUERY_STRING'
-                      ""
+                      nil
                     when 'RACK_ERRORS'
                       self['rack.errors']
                     when 'RACK_LOGGER'

data/lib/up/ruby/cluster_cli.rb

@@ -0,0 +1,10 @@
+require 'rack/builder'
+require 'up/ruby/rack_cluster'
+
+module Up
+  module CLI
+    def self.call
+      Up::Ruby::RackCluster.run(get_app, get_options)
+    end
+  end
+end

data/lib/up/ruby/rack_cluster.rb

@@ -0,0 +1,26 @@
+require 'up/ruby/rack_env'
+require 'up_ext'
+
+module Up
+  module Ruby
+    module RackCluster
+      def self.run(app, options = {})
+        raise "already running" if @server
+        @server = Up::Ruby::Cluster.new(app: app, **options).listen
+        true
+      end
+
+      def self.shutdown
+        @server&.stop
+        @server = nil
+      end
+    end
+  end
+end
+
+ENV['RACK_HANDLER'] ||= 'up'
+
+begin
+  ::Rackup::Handler.register('up', Up::Ruby::RackCluster) if defined?(::Rackup::Handler)
+rescue StandardError
+end

data/lib/up/ruby/rack_env.rb

@@ -0,0 +1,97 @@
+require 'logger'
+require 'up/version'
+
+module Up
+  module Ruby
+    class RackEnv < ::Hash
+      RACK_VARS = %w[rack.errors rack.hijack rack.hijack? rack.input rack.logger
+                    rack.multipart.buffer_size rack.multipart.tempfile_factory
+                    rack.response_finished
+                    rack.session rack.upgrade rack.upgrade? rack.url_scheme
+                    HTTP_ACCEPT HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE
+                    HTTP_CONNECTION HTTP_HOST HTTP_USER_AGENT PATH_INFO QUERY_STRING REQUEST_METHOD
+                    SCRIPT_NAME SERVER_NAME SERVER_PROTOCOL SERVER_SOFTWARE]
+      def initialize(req, config = {})
+        @req = req
+        @config = config
+      end
+
+      def [](key)
+        return super(key) if key?(key)
+        self[key] = case key
+                    when 'rack.errors'
+                      STDERR
+                    when 'rack.hijack'
+                      nil
+                    when 'rack.hijack?'
+                      false
+                    when 'rack.input'
+                      nil # ::IO.new
+                    when 'rack.logger'
+                      ::Logger.new(self['rack.errors'])
+                    when 'rack.multipart.buffer_size'
+                      4096
+                    when 'rack.multipart.tempfile_factory'
+                      proc { |_filename, _content_type| File.new }
+                    when 'rack.response_finished'
+                      []
+                    when 'rack.session'
+                      {}
+                    when 'rack.upgrade'
+                      nil
+                    when 'rack.upgrade?'
+                      nil
+                    when 'rack.url_scheme'
+                      @config[:scheme]
+                    when 'PATH_INFO'
+                      @req.get_url
+                    when 'QUERY_STRING'
+                      @req.get_query
+                    when 'RACK_ERRORS'
+                      self['rack.errors']
+                    when 'RACK_LOGGER'
+                      self['rack.logger']
+                    when 'REQUEST_METHOD'
+                      @req.get_method
+                    when 'SCRIPT_NAME'
+                      ""
+                    when 'SERVER_NAME'
+                      @config[:host]
+                    when 'SERVER_PORT'
+                      @config[:port].to_s
+                    when 'SERVER_PROTOCOL'
+                      @req.get_header('protocol')
+                    when 'SERVER_SOFTWARE'
+                      "#{@config[:handler]}/#{Up::VERSION} #{@config[:engine]}"
+                    else
+                      if key.start_with?('HTTP_')
+                        key = key[5..].gsub(/_/, '-')
+                        @req.get_header(key.downcase)
+                      else
+                        nil
+                      end
+                    end
+      end
+
+      def req_headers
+        @req.headers
+      end
+
+      def each
+        unless @got_them_all
+          RACK_VARS.each { |k| self[k] unless self.key?(k) }
+          @got_them_all = true
+        end
+        super
+      end
+
+      def to_s
+        unless @got_them_all
+          RACK_VARS.each { |k| self[k] unless self.key?(k) }
+          @got_them_all = true
+        end
+        super
+      end
+    end
+  end
+end