opal-up 0.0.4 → 0.0.6

data/ext/up_ext/up_ext.c

@@ -3,6 +3,7 @@
 #include <arpa/inet.h>
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <signal.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ -21,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;
@@ -39,6 +42,7 @@ 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;
@@ -65,6 +69,10 @@ static VALUE SERVER_NAME;
 static VALUE SERVER_PORT;
 static VALUE SERVER_PROTOCOL;
 
+// both used when worker of a cluster
+uws_app_t *cluster_app;
+struct us_listen_socket_t *cluster_socket;
+
 #define set_str_val(gl_name, str)                                              \
   rb_gc_register_address(&gl_name);                                            \
   (gl_name) = rb_enc_str_new((str), strlen((str)), binary_encoding);           \
@@ -358,12 +366,23 @@ response_error:
   uws_res_end_without_body(USE_SSL, res, false);
 }
 
+static void
+up_server_cluster_listen_handler(struct us_listen_socket_t *listen_socket,
+                                 uws_app_listen_config_t config, void *arg) {
+  if (listen_socket) {
+    cluster_socket = listen_socket;
+    fprintf(stderr, "Internal Cluster communication on http://localhost:%d\n",
+            config.port);
+  }
+}
+
 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,
+                                     void *arg) {
+  if (listen_socket) {
+    fprintf(stderr, "Server is listening on http://%s:%d\n", config.host,
             config.port);
+  }
 }
 
 const rb_data_type_t up_client_t = {.wrap_struct_name = "Up::Client",
@@ -395,14 +414,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;
@@ -431,12 +450,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)
@@ -451,20 +483,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;
@@ -721,9 +742,17 @@ upgrade_error:
   fprintf(stderr, "upgrade error");
 }
 
+static void up_internal_close_sockets(int signal) {
+  if (cluster_socket)
+    us_listen_socket_close(false, cluster_socket);
+  if (cluster_app)
+    uws_app_close(USE_SSL, cluster_app);
+}
+
 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
@@ -747,8 +776,16 @@ static VALUE up_server_listen(VALUE self) {
       .port = FIX2INT(s->port), .host = RSTRING_PTR(s->host), .options = 0};
   VALUE rmember_id = rb_ivar_get(self, at_member_id);
   if (rmember_id != Qnil) {
+    // got a cluster
     s->member_id = FIX2INT(rmember_id);
-    // got a cluster, open publish ports
+    // install signal handler
+    cluster_app = s->app;
+    cluster_socket = NULL;
+    struct sigaction upclcl = {.sa_handler = up_internal_close_sockets,
+                               .sa_flags = 0};
+    sigemptyset(&upclcl.sa_mask);
+    sigaction(SIGINT, &upclcl, NULL);
+    // open publish ports
     VALUE rworkers = rb_ivar_get(self, at_workers);
     s->workers = FIX2INT(rworkers);
     VALUE rsecret = rb_ivar_get(self, at_secret);
@@ -761,7 +798,14 @@ static VALUE up_server_listen(VALUE self) {
     uws_app_listen_config_t config_internal = {
         .port = config.port + s->member_id, .host = "localhost", .options = 0};
     uws_app_listen_with_config(false, s->app, config_internal,
-                               up_server_listen_handler, NULL);
+                               up_server_cluster_listen_handler, NULL);
+  } else {
+    cluster_app = s->app;
+    cluster_socket = NULL;
+    struct sigaction upclcl = {.sa_handler = up_internal_close_sockets,
+                               .sa_flags = 0};
+    sigemptyset(&upclcl.sa_mask);
+    sigaction(SIGINT, &upclcl, NULL);
   }
   uws_app_any(USE_SSL, s->app, "/*", up_server_request_handler, (void *)s);
   uws_ws(USE_SSL, s->app, "/*",
@@ -782,6 +826,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)
@@ -853,10 +924,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");
@@ -874,6 +954,7 @@ void Init_up_ext(void) {
   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");
@@ -911,11 +992,13 @@ void Init_up_ext(void) {
   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);
@@ -926,5 +1009,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

@@ -4,6 +4,13 @@ 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))
@@ -49,6 +56,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;
@@ -152,6 +160,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,24 +15,48 @@ 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
             super
           end
         end
-
-        Process.waitall
-        @members.each do |member|
-          Process.kill("KILL", member)
+        unless @member_id
+          install_signal_handlers
+          Process.waitall
         end
       end
 
       def stop
         if Up::CLI::stoppable?
-          @members.each { |m| Process.kill(m) } 
-          @members.clear
+          kill_members
+        end
+      end
+
+      private
+
+      def install_signal_handlers
+        Signal.trap('CHLD') do
+          warn "\nError: a cluster member died!"
+          kill_members
+        end
+        Signal.trap('INT') do
+          warn "\nReceived CTRL-C!"
+          kill_members
+        end
+      end
+
+      def kill_members
+        Signal.trap('CHLD', 'IGNORE')
+        STDERR.print "Stopping workers: "
+        @members.each do |mid|
+          Process.kill('INT', mid) rescue nil
+          STDERR.print '.'
         end
+        @members.clear
+        warn "\nCluster stopped."
+        Signal.trap('CHLD', 'DEFAULT')
       end
     end
   end

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

@@ -10,6 +10,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))
@@ -74,6 +81,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;
@@ -138,9 +146,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 +172,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.4'.freeze
+  VERSION = '0.0.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-up
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-12 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: []