opal-up 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd09c3697caf76eb487770a2818af0a06ee4711761a15f2d80d7d0d291747234
-  data.tar.gz: cc53773debbd42d66a2aa99e1b3d9ec3e3fcd05db99f5e58bfab94e5ecf1811a
+  metadata.gz: 46fd760653d3303f32429a4dfd767c4d93ac56817393785d7da35632ab2d4ad2
+  data.tar.gz: a809d96c97f31441dd51c8e5c87aeaee47059835718f62de3217b38348d7d111
 SHA512:
-  metadata.gz: 38c374376cfe497c4abd8039272ae616d44e5152d3ba15fc47578d789bd16d88cf8af21d2471fd71eafa0e3852f60704a0aabf03dd560bac2de5c87591724d1a
-  data.tar.gz: 0467d90a76aedd75515f38c678ce7cdcac7e36760a687c9ae6283dfdd9723ea2d0e005d67e357fbcf60491c594511c45be105002a008f650c2eb488f5f315c53
+  metadata.gz: 6cd09583959a4340bafda2c118a570df793884fc2813e2b93a251f26220e243910263093c3ff24ac8f9dcc337af5cf1c152f5c9a491e58a5dcc32d035ef5c545
+  data.tar.gz: 7e45708e9f770ea45dd463dd5bf39075d7d241fe73d0ea60d638e6d80369dec4ae16661b9187525b522440133fa0272df62ca1c982bb132737807c9e05dae6f3

data/README.md

@@ -84,21 +84,21 @@ Available with `bundle exec` within the example apps or if this gem is included
 Usage: up [options]
 
     -h, --help                       Show this message
-    -p, --port PORT                  Port number the server will listen to
-    -b, --bind ADDRESS               Address the server will listen to
+    -p, --port PORT                  Port number the server will listen to. Default: 3000
+    -b, --bind ADDRESS               Address the server will listen to. Default: localhost
     -s, --secure                     Use secure sockets.
 When using secure sockets, the -a, -c and -k options must be provided
     -a, --ca-file FILE               File with CA certs
     -c, --cert-file FILE             File with the servers certificate
     -k, --key-file FILE              File with the servers certificate
+    -l, --log-file FILE              Log file
     -v, --version                    Show version
-
+    -w, --workers NUMBER             For clusters, the number of workers to run. Default: number of processors
 ```
 ## Supported Features
 
 Up! implements the [Rack Spec as of Rack 3.0](https://github.com/rack/rack/blob/main/SPEC.rdoc) with the following differences:
 - `rack.hijack` is not implemented, but `rack.upgrade` instead is, see "Websockets" below
-- `rack.input` is currently still missing
 - Tempfile support is currently incomplete, affecting a few keys in the Rack Env ('tempfile' missing in Opal).
 - Some Rack modules/classes still have issues when run in Opal and may not work as expected
 

data/ext/up_ext/up_ext.c

@@ -22,7 +22,9 @@ static VALUE cLogger;
 
 static ID at_env;
 static ID at_handler;
+static ID at_instance;
 static ID at_member_id;
+static ID at_members;
 static ID at_open;
 static ID at_protocol;
 static ID at_secret;
@@ -35,11 +37,13 @@ static ID id_close;
 static ID id_each;
 static ID id_host;
 static ID id_logger;
+static ID id_new;
 static ID id_on_close;
 static ID id_on_drained;
 static ID id_on_message;
 static ID id_on_open;
 static ID id_port;
+static ID id_publish;
 
 static rb_encoding *utf8_encoding;
 static rb_encoding *binary_encoding;
@@ -119,6 +123,8 @@ typedef struct server_s {
   VALUE port;
   VALUE logger;
   VALUE env_template;
+  VALUE body;
+  VALUE env;
   int workers;
   int member_id;
   char secret[37];
@@ -280,6 +286,43 @@ typedef struct publish_data_s {
   server_s *s;
 } publish_data_s;
 
+static void up_internal_call_app(server_s *s, uws_res_t *res, VALUE env) {
+  // call app
+  VALUE rres = rb_funcall(s->rapp, id_call, 1, env);
+
+  if (TYPE(rres) != T_ARRAY)
+    goto response_error;
+
+  // response status
+  VALUE rstatus = rb_ary_entry(rres, 0);
+  if (!up_internal_set_response_status(res, rstatus))
+    goto response_error;
+
+  // collect headers
+  VALUE rheaders = rb_ary_entry(rres, 1);
+  if (TYPE(rheaders) != T_HASH)
+    goto response_error;
+  rb_hash_foreach(rheaders, up_internal_res_header_handler, (VALUE)res);
+
+  // collect response body
+  VALUE rparts = rb_ary_entry(rres, 2);
+  up_internal_collect_response_body(res, rparts);
+
+  // end response
+  uws_res_end_without_body(USE_SSL, res, false);
+
+  // close resources if necessary
+  if (rb_respond_to(rparts, id_close))
+    rb_funcall(rparts, id_close, 0);
+
+  return;
+response_error:
+  fprintf(stderr, "response error\n");
+  uws_res_end_without_body(USE_SSL, res, false);
+}
+
+static void up_internal_abort_data(uws_res_t *res, void *arg) {}
+
 static void up_internal_process_publish_post_data(uws_res_t *res,
                                                   const char *chunk,
                                                   size_t chunk_length,
@@ -296,9 +339,22 @@ static void up_internal_process_publish_post_data(uws_res_t *res,
       break;
     }
   }
-  if (channel_length > 0 && message_length > 0) {
+  if (channel_length > 0 && message_length > 0)
     uws_publish(USE_SSL, s->app, channel_start, channel_length, message_start,
                 message_length, TEXT, false);
+}
+
+static void up_internal_process_post_data(uws_res_t *res, const char *chunk,
+                                          size_t chunk_length, bool is_end,
+                                          void *arg) {
+  server_s *s = (server_s *)arg;
+  rb_str_cat(s->body, chunk, chunk_length);
+  if (is_end) {
+    // set rack.input
+    rb_hash_aset(s->env, rack_input, rb_funcall(cStringIO, id_new, 1, s->body));
+    up_internal_call_app(s, res, s->env);
+    s->body = Qnil;
+    s->env = Qnil;
   }
 }
 
@@ -319,48 +375,25 @@ static void up_internal_publish_handler(uws_res_t *res, uws_req_t *req,
   }
 }
 
-static void up_server_request_handler(uws_res_t *res, uws_req_t *req,
-                                      void *arg) {
+static void up_server_any_handler(uws_res_t *res, uws_req_t *req, void *arg) {
   // prepare rack env
   server_s *s = (server_s *)arg;
-  VALUE renv = rb_hash_dup(s->env_template);
-  up_server_prepare_env(renv, req);
-
-  // call app
-  VALUE rres = rb_funcall(s->rapp, id_call, 1, renv);
-  if (TYPE(rres) != T_ARRAY)
-    goto response_error;
-
-  // response status
-  VALUE rstatus = rb_ary_entry(rres, 0);
-  if (!up_internal_set_response_status(res, rstatus))
-    goto response_error;
-
-  // collect headers
-  VALUE rheaders = rb_ary_entry(rres, 1);
-  if (TYPE(rheaders) != T_HASH)
-    goto response_error;
-  rb_hash_foreach(rheaders, up_internal_res_header_handler, (VALUE)res);
-
-  // collect response body
-  VALUE rparts = rb_ary_entry(rres, 2);
-  up_internal_collect_response_body(res, rparts);
-
-  // end response
-  uws_res_end_without_body(USE_SSL, res, false);
+  VALUE env = rb_hash_dup(s->env_template);
+  up_server_prepare_env(env, req);
+  up_internal_call_app(s, res, env);
+  RB_GC_GUARD(env);
+}
 
-  // close resources if necessary
-  if (rb_respond_to(rparts, id_close))
-    rb_funcall(rparts, id_close, 0);
+static void up_server_post_handler(uws_res_t *res, uws_req_t *req, void *arg) {
+  // prepare rack env
+  server_s *s = (server_s *)arg;
+  s->env = rb_hash_dup(s->env_template);
+  up_server_prepare_env(s->env, req);
 
-  return;
-  RB_GC_GUARD(rstatus);
-  RB_GC_GUARD(rheaders);
-  RB_GC_GUARD(rres);
-  RB_GC_GUARD(renv);
-response_error:
-  fprintf(stderr, "response error\n");
-  uws_res_end_without_body(USE_SSL, res, false);
+  // receive POST data
+  s->body = rb_enc_str_new("", 0, utf8_encoding);
+  uws_res_on_data(USE_SSL, res, up_internal_process_post_data, (void *)s);
+  uws_res_on_aborted(USE_SSL, res, up_internal_abort_data, NULL);
 }
 
 static void
@@ -411,14 +444,14 @@ static VALUE up_client_pending(VALUE self) {
   return INT2FIX(0);
 }
 
-static void up_client_cluster_publish(server_s *s, int st, VALUE channel,
+static void up_client_cluster_publish(char *scrt, int st, VALUE channel,
                                       VALUE message) {
   const char *opening_line = "POST " INTERNAL_PUBLISH_PATH " HTTP/1.1\r\n";
   const char *host_header = "Host: localhost\r\n";
   const char *secret = "Secret: ";
   char secret_header[50];
   memcpy(secret_header, secret, 8);
-  memcpy(secret_header + 8, s->secret, 36);
+  memcpy(secret_header + 8, scrt, 36);
   memcpy(secret_header + 8 + 36, "\r\n", 2);
   const char *content_type = "Content-Type: text/plain\r\n";
   long c_length = RSTRING_LEN(channel) + RSTRING_LEN(message) + 2;
@@ -447,12 +480,25 @@ static void up_client_cluster_publish(server_s *s, int st, VALUE channel,
   // fprintf(stderr, "read: %s\n", read_buf);
 }
 
-static VALUE up_client_publish(int argc, VALUE *argv, VALUE self) {
+static void up_internal_publish_to_member(server_s *s, VALUE channel,
+                                          VALUE message, int member_idx) {
+  struct sockaddr_in member_addr = {.sin_addr.s_addr = inet_addr("127.0.0.1"),
+                                    .sin_family = AF_INET};
+  int st = socket(AF_INET, SOCK_STREAM, 0);
+  if (st) {
+    member_addr.sin_port = htons(FIX2INT(s->port) + member_idx);
+    if (connect(st, (struct sockaddr *)&member_addr,
+                sizeof(struct sockaddr_in)) == 0) {
+      up_client_cluster_publish(s->secret, st, channel, message);
+      close(st);
+    }
+  }
+}
+
+static VALUE up_client_publish(VALUE self, VALUE channel, VALUE message) {
   uws_websocket_t *ws = DATA_PTR(self);
   if (!ws)
     return Qnil;
-  VALUE channel, message, engine;
-  rb_scan_args(argc, argv, "21", &channel, &message, &engine);
   if (TYPE(channel) != T_STRING)
     channel = rb_obj_as_string(channel);
   if (TYPE(message) != T_STRING)
@@ -467,20 +513,9 @@ static VALUE up_client_publish(int argc, VALUE *argv, VALUE self) {
 
       // publish to cluster members
       int i;
-      struct sockaddr_in member_addr = {
-          .sin_addr.s_addr = inet_addr("127.0.0.1"), .sin_family = AF_INET};
       for (i = 1; i <= s->workers; i++) {
-        if (i != s->member_id) {
-          int st = socket(AF_INET, SOCK_STREAM, 0);
-          if (st) {
-            member_addr.sin_port = htons(FIX2INT(s->port) + i);
-            if (connect(st, (struct sockaddr *)&member_addr,
-                        sizeof(struct sockaddr_in)) == 0) {
-              up_client_cluster_publish(s, st, channel, message);
-              close(st);
-            }
-          }
-        }
+        if (i != s->member_id)
+          up_internal_publish_to_member(s, channel, message, i);
       }
     }
     return res ? Qtrue : Qfalse;
@@ -608,8 +643,8 @@ void up_ws_drain_handler(uws_websocket_t *ws, void *user_data) {
 
 void up_ws_ping_handler(uws_websocket_t *ws, const char *message, size_t length,
                         void *user_data) {
-  /* You don't need to handle this one, we automatically respond to pings as per
-   * standard */
+  /* You don't need to handle this one, we automatically respond to pings as
+   * per standard */
 }
 
 void up_ws_pong_handler(uws_websocket_t *ws, const char *message, size_t length,
@@ -747,6 +782,7 @@ static void up_internal_close_sockets(int signal) {
 static VALUE up_server_listen(VALUE self) {
   server_s *s = DATA_PTR(self);
   up_internal_check_arg_types(s->rapp, &s->host, &s->port);
+  rb_ivar_set(mUp, at_instance, self);
 
   s->env_template = rb_hash_dup(rack_env_template);
   // When combined with SCRIPT_NAME and PATH_INFO, these variables can be used
@@ -801,7 +837,8 @@ static VALUE up_server_listen(VALUE self) {
     sigemptyset(&upclcl.sa_mask);
     sigaction(SIGINT, &upclcl, NULL);
   }
-  uws_app_any(USE_SSL, s->app, "/*", up_server_request_handler, (void *)s);
+  uws_app_post(USE_SSL, s->app, "/*", up_server_post_handler, (void *)s);
+  uws_app_any(USE_SSL, s->app, "/*", up_server_any_handler, (void *)s);
   uws_ws(USE_SSL, s->app, "/*",
          (uws_socket_behavior_t){.compression = DISABLED,
                                  .maxPayloadLength = 5 * 1024 * 1024,
@@ -820,6 +857,33 @@ static VALUE up_server_listen(VALUE self) {
   return self;
 }
 
+static VALUE up_server_publish(VALUE self, VALUE channel, VALUE message) {
+  if (TYPE(channel) != T_STRING)
+    channel = rb_obj_as_string(channel);
+  if (TYPE(message) != T_STRING)
+    message = rb_obj_as_string(message);
+  server_s *s = DATA_PTR(self);
+  VALUE members = rb_ivar_get(self, at_members);
+  if (members != Qnil) {
+    long i, mb_cnt = RARRAY_LEN(members);
+    for (i = 0; i < mb_cnt; i++) {
+      up_internal_publish_to_member(s, channel, message, i);
+    }
+  } else {
+    uws_publish(USE_SSL, s->app, RSTRING_PTR(channel), RSTRING_LEN(channel),
+                RSTRING_PTR(message), RSTRING_LEN(message), TEXT, false);
+    if (s->member_id > 0) {
+      // publish to cluster members
+      int i;
+      for (i = 1; i <= s->workers; i++) {
+        if (i != s->member_id)
+          up_internal_publish_to_member(s, channel, message, i);
+      }
+    }
+  }
+  return Qtrue;
+}
+
 static VALUE up_server_stop(VALUE self) {
   server_s *s = DATA_PTR(self);
   if (!s->app)
@@ -891,10 +955,19 @@ void up_setup_rack_env_template(void) {
   rb_hash_aset(rack_env_template, HTTP_VERSION, http11);
 }
 
+static VALUE up_publish(VALUE self, VALUE channel, VALUE message) {
+  VALUE instance = rb_ivar_get(mUp, at_instance);
+  if (instance != Qnil)
+    return rb_funcall(instance, id_publish, 2, channel, message);
+  return Qfalse;
+}
+
 void Init_up_ext(void) {
   at_env = rb_intern("@env");
   at_handler = rb_intern("@handler");
+  at_instance = rb_intern("@instance");
   at_member_id = rb_intern("@member_id");
+  at_members = rb_intern("@members");
   at_open = rb_intern("@open");
   at_protocol = rb_intern("@protocol");
   at_secret = rb_intern("@secret");
@@ -907,11 +980,13 @@ void Init_up_ext(void) {
   id_each = rb_intern("each");
   id_host = rb_intern("host");
   id_logger = rb_intern("logger");
+  id_new = rb_intern("new");
   id_on_close = rb_intern("on_close");
   id_on_drained = rb_intern("on_drained");
   id_on_message = rb_intern("on_message");
   id_on_open = rb_intern("on_open");
   id_port = rb_intern("port");
+  id_publish = rb_intern("publish");
 
   utf8_encoding = rb_enc_find("UTF-8");
   binary_encoding = rb_enc_find("binary");
@@ -937,23 +1012,25 @@ void Init_up_ext(void) {
   rb_gc_register_address(&cLogger);
   cLogger = rb_const_get(rb_cObject, rb_intern("Logger"));
   rb_gc_register_address(&default_logger);
-  default_logger = rb_funcall(cLogger, rb_intern("new"), 1, rb_stderr);
+  default_logger = rb_funcall(cLogger, id_new, 1, rb_stderr);
 
   rb_require("stringio");
 
   rb_gc_register_address(&cStringIO);
   cStringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
   rb_gc_register_address(&default_input);
-  default_input = rb_funcall(cStringIO, rb_intern("new"), 1, empty_string);
+  default_input = rb_funcall(cStringIO, id_new, 1, empty_string);
 
   up_setup_rack_env_template();
 
   mUp = rb_define_module("Up");
+  rb_define_singleton_method(mUp, "publish", up_publish, 2);
+
   cClient = rb_define_class_under(mUp, "Client", rb_cObject);
   rb_define_alloc_func(cClient, up_client_alloc);
   rb_define_method(cClient, "close", up_client_close, 0);
   rb_define_method(cClient, "pending", up_client_pending, 0);
-  rb_define_method(cClient, "publish", up_client_publish, -1);
+  rb_define_method(cClient, "publish", up_client_publish, 2);
   rb_define_method(cClient, "subscribe", up_client_subscribe, -1);
   rb_define_method(cClient, "unsubscribe", up_client_unsubscribe, -1);
   rb_define_method(cClient, "write", up_client_write, 1);
@@ -964,5 +1041,6 @@ void Init_up_ext(void) {
   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, "publish", up_server_publish, 2);
   rb_define_method(cServer, "stop", up_server_stop, 0);
 }

data/lib/up/bun/server.rb

@@ -1,9 +1,17 @@
 # backtick_javascript: true
 require 'logger'
+require 'stringio'
 require 'up/cli'
 require 'up/client'
 
 module Up
+  class << self
+    def publish(channel, message)
+      raise 'no instance running' unless @instance
+      @instance&.publish(channel, message)
+    end
+  end
+
   module Bun
     class Server
       def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR))
@@ -16,7 +24,7 @@ module Up
         @ca_file   = ca_file
         @cert_file = cert_file
         @key_file  = key_file
-        @default_input = IO.new
+        @default_input = StringIO.new('', 'r')
         @server    = nil
         @logger    = logger
         @t_factory = proc { |filename, _content_type| File.new(filename, 'a+') }
@@ -49,6 +57,7 @@ module Up
       }
       def listen
         raise "already running" if @server
+        ::Up.instance_variable_set(:@instance, self)
         %x{
           const oubs = Opal.Up.Bun.Server;
           const ouwc = Opal.Up.Client;
@@ -57,11 +66,17 @@ module Up
             port: #@port,
             hostname: #@host,
             development: false,
-            fetch(req, server) {
+            async fetch(req, server) {
               const upgrade = req.headers.get('Upgrade');
               const env = new Map();
               env.set('rack.errors',#{STDERR});
-              env.set('rack.input', #@default_input);
+              if (req.method === 'POST') {
+                let body = await req.text();
+                console.log('received: ', body);
+                env.set('rack.input', #{StringIO.new(`body`)});
+              } else {
+                env.set('rack.input', #@default_input);
+              }
               env.set('rack.logger', #@logger);
               env.set('rack.multipart.buffer_size', 4096);
               env.set('rack.multipart.tempfile_factory', #@t_factory);
@@ -152,6 +167,15 @@ module Up
         }
       end
 
+      def publish(channel, message)
+        %x{
+          if (!message.$$is_string) {
+            message = JSON.stringify(message);
+          }
+          #@server.publish(channel, message);
+        }
+      end
+
       def stop
         if Up::CLI::stoppable?
           `#@server.stop()`

data/lib/up/cli.rb

@@ -14,10 +14,10 @@ module Up
           puts self
           exit
         end
-        on('-p', '--port PORT', String, 'Port number the server will listen to') do |port|
+        on('-p', '--port PORT', String, 'Port number the server will listen to. Default: 3000') do |port|
           options[:port] = port.to_i
         end
-        on('-b', '--bind ADDRESS', String, 'Address the server will listen to') do |host|
+        on('-b', '--bind ADDRESS', String, 'Address the server will listen to. Default: localhost') do |host|
           options[:host] = host
         end
         on('-s', '--secure', "Use secure sockets.\nWhen using secure sockets, the -a, -c and -k options must be provided") do
@@ -32,13 +32,16 @@ module Up
         on('-k', '--key-file FILE', String, 'File with the servers certificate') do |key_file|
           options[:key_file] = key_file
         end
-        on('-l', '--log-file FILE', String, 'log file') do |log_file|
+        on('-l', '--log-file FILE', String, 'Log file') do |log_file|
           options[:logger] = Logger.new(File.new(log_file, 'a+'))
         end
         on('-v', '--version', 'Show version') do
           puts "Up! v#{Up::VERSION}"
           exit
         end
+        on('-w', '--workers NUMBER', 'For clusters, the number of workers to run. Default: number of processors') do |workers|
+          options[:workers] = workers.to_i
+        end
       end
 
       def parse!

data/lib/up/client.rb

@@ -36,15 +36,14 @@ module Up
         `#@ws?.getBufferedAmount()`
       end
 
-      def publish(channel, message, engine = nil)
+      def publish(channel, message)
         res = false
-        raise 'publish engine not supported' if engine
         %x{
           if (!message.$$is_string) {
             message = JSON.stringify(message);
           }
           res = #@server?.publish(channel, message);
-          if (engine !== false && self.worker) {
+          if (#@worker) {
             process.send({c: channel, m: message});
           }
         }

data/lib/up/ruby/cluster.rb

@@ -15,6 +15,7 @@ module Up
 
       def listen
         raise "already running" unless @members.empty?
+        ::Up.instance_variable_set(:@instance, self)
         @workers.times do
           @members << fork do
             @member_id = @members.size + 1

data/lib/up/u_web_socket/cluster.rb

@@ -18,6 +18,7 @@ module Up
 
       def listen
         raise "already running" unless @members.empty?
+        ::Up.instance_variable_set(:@instance, self)
         %x{
           if (cluster.isPrimary) {
             cluster.on('message', (worker, message, handle) => {
@@ -33,9 +34,9 @@ module Up
               #@members[i] = cluster.fork();
             }
           } else {
-            self.worker = true;
+            #@worker = true;
             function process_message_handler(message, handle) {
-              self.server.publish(message.c, message.m);
+              #@server.publish(message.c, message.m);
             }
             process.on('message', process_message_handler);
             #{super}
@@ -43,6 +44,25 @@ module Up
         }
       end
 
+      def publish(channel, message)
+        %x{
+          if (!message.$$is_string) {
+            message = JSON.stringify(message);
+          }
+          if (#@worker ) {
+            #@server?.publish(channel, message);
+            process.send({c: channel, m: message});
+          } else if (#@members) {
+            for (let member of #@members) {
+              if (member !== worker) {
+                member.send(message);
+              }
+            }
+          }
+        }
+        true
+      end
+
       def stop
         if Up::CLI::stoppable?
           @members.each { |m| `m.kill()` } 

data/lib/up/u_web_socket/server.rb

@@ -1,5 +1,6 @@
 # backtick_javascript: true
 require 'logger'
+require 'stringio'
 require 'up/cli'
 require 'up/client'
 
@@ -10,6 +11,13 @@ require 'up/client'
 }
 
 module Up
+  class << self
+    def publish(channel, message)
+      raise 'no instance running' unless @instance
+      @instance&.publish(channel, message)
+    end
+  end
+
   module UWebSocket
     class Server
       def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR))
@@ -22,7 +30,7 @@ module Up
         @ca_file   = ca_file
         @cert_file = cert_file
         @key_file  = key_file
-        @default_input = IO.new
+        @default_input = StringIO.new('', 'r')
         @server    = nil
         @logger    = logger
         @t_factory = proc { |filename, _content_type| File.new(filename, 'a+') }
@@ -51,20 +59,20 @@ module Up
           #{`parts`.close if `parts`.respond_to?(:close)}
         }
 
-        self.prepare_env = function(req) {
+        self.prepare_env = function(req, ins) {
           const env = new Map();
           env.set('rack.errors',#{STDERR});
-          env.set('rack.input', #@default_input);
-          env.set('rack.logger', #@logger);
+          env.set('rack.input', ins.default_input);
+          env.set('rack.logger', ins.logger);
           env.set('rack.multipart.buffer_size', 4096);
-          env.set('rack.multipart.tempfile_factory', #@t_factory);
-          env.set('rack.url_scheme', #@scheme);
+          env.set('rack.multipart.tempfile_factory', ins.t_factory);
+          env.set('rack.url_scheme', ins.scheme);
           env.set('SCRIPT_NAME', "");
           env.set('SERVER_PROTOCOL', 'HTTP/1.1');
           env.set('HTTP_VERSION', 'HTTP/1.1');
-          env.set('SERVER_NAME', #@host);
-          env.set('SERVER_PORT', #@port);
-          env.set('QUERY_STRING', req.getQuery());
+          env.set('SERVER_NAME', ins.host);
+          env.set('SERVER_PORT', ins.port);
+          env.set('QUERY_STRING', req.getQuery() || '');
           env.set('REQUEST_METHOD', req.getMethod().toUpperCase());
           env.set('PATH_INFO', req.getUrl());
           req.forEach((k, v) => { env.set('HTTP_' + k.toUpperCase().replaceAll('-', '_'), v) });
@@ -74,6 +82,7 @@ module Up
 
       def listen
         raise "already running" if @server
+        ::Up.instance_variable_set(:@instance, self)
         %x{
           const ouws = Opal.Up.UWebSocket.Server;
           const ouwc = Opal.Up.Client;
@@ -83,8 +92,24 @@ module Up
           } else {
             #@server = uws.App();
           }
+          #@server.post('/*', (res, req) => {
+            const env = ouws.prepare_env(req, self);
+            let buffer = Buffer.from('');
+            res.onData((chunk, is_last) => {
+              buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+              if (is_last === true) {
+                env.set('rack.input', #{StringIO.new(`buffer.toString()`)});
+                const rack_res = #@app.$call(env);
+                res.writeStatus(rack_res[0].toString() + ' OK');
+                ouws.handle_headers(rack_res[1], res);
+                ouws.handle_response(rack_res[2], res);
+                res.end();
+              }
+            });
+            res.onAborted(() => {});
+          });
           #@server.any('/*', (res, req) => {
-            const rack_res = #@app.$call(ouws.prepare_env(req));
+            const rack_res = #@app.$call(ouws.prepare_env(req, self));
             res.writeStatus(rack_res[0].toString() + ' OK');
             ouws.handle_headers(rack_res[1], res);
             ouws.handle_response(rack_res[2], res);
@@ -128,7 +153,7 @@ module Up
             },
             sendPingsAutomatically: true,
             upgrade: (res, req, context) => {
-              const env = ouws.prepare_env(req);
+              const env = ouws.prepare_env(req, self);
               env.set('rack.upgrade?', #{:websocket});
               const rack_res = #@app.$call(env);
               const handler = env.get('rack.upgrade');
@@ -138,9 +163,9 @@ module Up
                 client.open = false;
                 client.handler = handler
                 client.protocol = #{:websocket};
-                client.server = self.server;
+                client.server = #@server;
                 client.timeout = 120;
-                if (self.worker) {
+                if (#@worker) {
                   client.worker = true;
                 }
                 res.upgrade({ client: client },
@@ -164,6 +189,15 @@ module Up
         }
       end
 
+      def publish(channel, message)
+        %x{
+          if (!message.$$is_string) {
+            message = JSON.stringify(message);
+          }
+          #@server.publish(channel, message);
+        }
+      end
+
       def stop
         if Up::CLI::stoppable?
           `#@server.close()`

data/lib/up/version.rb

@@ -1,3 +1,3 @@
 module Up
-  VERSION = '0.0.5'.freeze
+  VERSION = '0.0.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-up
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-14 00:00:00.000000000 Z
+date: 2024-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -58,26 +58,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.9
-- !ruby/object:Gem::Dependency
-  name: rackup
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.2
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.2
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -201,7 +181,7 @@ files:
 - lib/up/u_web_socket/server.rb
 - lib/up/u_web_socket/server_cli.rb
 - lib/up/version.rb
-homepage: ''
+homepage: https://github.com/janbiedermann/up
 licenses:
 - MIT
 metadata: {}
@@ -223,5 +203,5 @@ requirements: []
 rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
-summary: Rack server for Opal
+summary: Rack server for Opal and Ruby
 test_files: []