opal-up 0.0.2 → 0.0.4

data/lib/up/bun/rack_env.rb

@@ -23,26 +23,14 @@ module Up
         self[key] = case key
                     when 'rack.errors'
                       STDERR
-                    when 'rack.hijack'
-                      nil
-                    when 'rack.hijack?'
-                      false
-                    when 'rack.input'
-                      ::IO.new
                     when 'rack.logger'
-                      ::Logger.new(self['rack.errors'])
+                      @config[:logger]
                     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'

data/lib/up/bun/server.rb

@@ -1,36 +1,37 @@
 # backtick_javascript: true
+require 'logger'
 require 'up/cli'
-require 'up/bun/rack_env'
+require 'up/client'
 
 module Up
   module Bun
     class Server
-      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil)
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR))
         @app = app
         @scheme    = scheme || 'http'
         raise "unsupported scheme #{@scheme}" unless %w[http https].include?(@scheme)
         @host      = host || 'localhost'
         @port      = port&.to_i || 3000
-        @config    = { handler: self.class.name, engine: "bun/#{`process.version`}", port: port, scheme: scheme, host: host }.freeze
+        @config    = { handler: self.class.name, engine: "bun/#{`process.version`}", port: port, scheme: scheme, host: host, logger: logger }.freeze
         @ca_file   = ca_file
         @cert_file = cert_file
         @key_file  = key_file
-        @server = nil
+        @default_input = IO.new
+        @server    = nil
+        @logger    = logger
+        @t_factory = proc { |filename, _content_type| File.new(filename, 'a+') }
       end
 
       %x{
         self.handle_headers = function(rack_headers, bun_hdr) {
           if (rack_headers.$$is_hash) {
-            var header, k, v;
+            var header, v;
             for(header of rack_headers) {
-              k = header[0];
-              if (!k.startsWith('rack.')) {
-                v = header[1];
-                if (v.$$is_array) {
-                  v = v.join("\n");
-                }
-                bun_hdr.set(k, v);
+              v = header[1];
+              if (v.$$is_array) {
+                v = v.join("\n");
               }
+              bun_hdr.set(header[0].toLowerCase(), v);
             }
           }
         }
@@ -49,20 +50,93 @@ module Up
       def listen
         raise "already running" if @server
         %x{
-          const oubr = Opal.Up.Bun.RackEnv;
           const oubs = Opal.Up.Bun.Server;
-
+          const ouwc = Opal.Up.Client;
+          const deco = new TextDecoder();
           var server_options = {
             port: #@port,
             hostname: #@host,
             development: false,
-            fetch(req) {
-              const rack_res = #@app.$call(oubr.$new(req, #@config));
-              const hdr = new Headers();
-              oubs.handle_headers(rack_res[1]);
+            fetch(req, server) {
+              const upgrade = req.headers.get('Upgrade');
+              const env = new Map();
+              env.set('rack.errors',#{STDERR});
+              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);
+              if (upgrade) {
+                env.set('rack.upgrade?', #{:websocket});
+              }
+              env.set('rack.url_scheme', #@scheme);
+              env.set('SCRIPT_NAME', "");
+              env.set('SERVER_PROTOCOL', req.httpVersion);
+              env.set('HTTP_VERSION', req.httpVersion);
+              env.set('SERVER_NAME', #@host);
+              env.set('SERVER_PORT', #@port);
+              env.set('QUERY_STRING', "");
+              env.set('REQUEST_METHOD', req.method);
+              env.set('PATH_INFO', req.url);
+              req.headers.forEach((k, v) => { env.set('HTTP_' + k.toUpperCase().replaceAll('-', '_'), v) });
+              const rack_res = #@app.$call(env);
+              if (upgrade) {
+                const handler = env.get('rack.upgrade');
+                if (rack_res[0] < 300 && handler && handler !== nil) {
+                  const client = ouwc.$new();
+                  client.env = env;
+                  client.open = false;
+                  client.handler = handler
+                  client.protocol = #{:websocket};
+                  client.server = server;
+                  client.timeout = 120;
+                  server.upgrade(req, { data: { client: client }});
+                  return;
+                }
+              }
+              const hdrs = new Headers();
+              oubs.handle_headers(rack_res[1], hdrs);
               var body = '';
               body = oubs.handle_response(rack_res[2], body);
-              return new Response(body, {status: rack_res[0], statusText: 'OK', headers: hdr});
+              return new Response(body, {status: rack_res[0], statusText: 'OK', headers: hdrs});
+            },
+            websocket: {
+              close: (ws) => {
+                const client = ws.data.client;
+                if (typeof(client.handler.$on_close) === 'function') {
+                  client.ws = ws;
+                  client.open = false;
+                  client.handler.$on_close(client);
+                  client.ws = null;
+                }
+              },
+              drain: (ws) => {
+                const client = ws.data.client;
+                if (typeof(client.handler.$on_drained) === 'function') {
+                  client.ws = ws;
+                  client.handler.$on_drained(client);
+                  client.ws = null;
+                }
+              },
+              message: (ws, message) => {
+                const client = ws.data.client;
+                if (typeof(client.handler.$on_message) === 'function') {
+                  if (typeof(message) !== 'string') {
+                    message = deco.decode(message);
+                  }
+                  client.ws = ws;
+                  client.handler.$on_message(client, message);
+                  client.ws = null;
+                }
+              },
+              open: (ws) => {
+                const client = ws.data.client;
+                if (typeof(client.handler.$on_open) === 'function') {
+                  client.ws = ws;
+                  client.open = true;
+                  client.handler.$on_open(client);
+                  client.ws = null;
+                }
+              } 
             }
           };
           if (#@scheme === 'https') {

data/lib/up/cli.rb

@@ -32,6 +32,9 @@ 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|
+          options[:logger] = Logger.new(File.new(log_file, 'a+'))
+        end
         on('-v', '--version', 'Show version') do
           puts "Up! v#{Up::VERSION}"
           exit

data/lib/up/client.rb

@@ -0,0 +1,68 @@
+# backtick_javascript: true
+if RUBY_ENGINE == 'opal'
+  %x{
+    const process = require('node:process');
+  }
+end
+
+module Up
+  class Client
+    # instance vars are set by the server
+
+    attr_reader :env, :handler, :protocol, :timeout
+
+    def handler=(h)
+      @handler.on_close(self)
+      @handler = h
+      @handler.on_open(self)
+    end
+
+    def open?
+      @open
+    end
+
+    def pubsub?
+      true
+    end
+
+    if RUBY_ENGINE == 'opal'
+      def close
+        @open = false
+        `#@ws?.close()`
+      end
+
+      def pending
+        return -1 unless @open
+        `#@ws?.getBufferedAmount()`
+      end
+
+      def publish(channel, message, engine = nil)
+        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) {
+            process.send({c: channel, m: message});
+          }
+        }
+        res
+      end
+
+      def subscribe(channel, is_pattern = false, &block)
+        @sub_block = block
+        `#@ws?.subscribe(channel)`
+      end
+
+      def unsubscribe(channel, is_pattern = false)
+        `#@ws?.unsubscribe(channel)`
+      end
+
+      def write(data)
+        `#@ws?.send(data, false)`
+      end
+    end
+  end
+end

data/lib/up/ruby/cluster.rb

@@ -0,0 +1,39 @@
+# backtick_javascript: true
+require 'etc'
+require 'random/formatter'
+require 'up_ext'
+
+module Up
+  module Ruby
+    class Cluster < Up::Ruby::Server
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR), workers: nil)
+        super(app: app, host: host, port: port)
+        @secret = Random.uuid
+        @workers = workers || Etc.nprocessors
+        @members = []
+      end
+
+      def listen
+        raise "already running" unless @members.empty?
+        @workers.times do
+          @members << fork do
+            @member_id = @members.size + 1
+            super
+          end
+        end
+
+        Process.waitall
+        @members.each do |member|
+          Process.kill("KILL", member)
+        end
+      end
+
+      def stop
+        if Up::CLI::stoppable?
+          @members.each { |m| Process.kill(m) } 
+          @members.clear
+        end
+      end
+    end
+  end
+end

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/{node → ruby}/rack_cluster.rb

@@ -1,11 +1,12 @@
-require 'up/node/cluster'
+require 'up_ext'
+require 'up/ruby/cluster'
 
 module Up
-  module Node
+  module Ruby
     module RackCluster
       def self.run(app, options = {})
         raise "already running" if @server
-        @server = Up::Node::Cluster.new(app: app, **options).listen
+        @server = Up::Ruby::Cluster.new(app: app, **options).listen
         true
       end
 
@@ -20,6 +21,6 @@ end
 ENV['RACK_HANDLER'] ||= 'up'
 
 begin
-  ::Rackup::Handler.register('up', Up::Node::RackCluster) if defined?(::Rackup::Handler)
+  ::Rackup::Handler.register('up', Up::Ruby::RackCluster) if defined?(::Rackup::Handler)
 rescue StandardError
 end

data/lib/up/{node → ruby}/rack_server.rb

@@ -1,11 +1,11 @@
-require 'up/node/server'
+require 'up_ext'
 
 module Up
-  module Node
+  module Ruby
     module RackServer
       def self.run(app, options = {})
         raise "already running" if @server
-        @server = Up::Node::Server.new(app: app, **options).listen
+        @server = Up::Ruby::Server.new(app: app, **options).listen
         true
       end
 
@@ -20,6 +20,6 @@ end
 ENV['RACK_HANDLER'] ||= 'up'
 
 begin
-  ::Rackup::Handler.register('up', Up::Node::RackServer) if defined?(::Rackup::Handler)
+  ::Rackup::Handler.register('up', Up::Ruby::RackServer) if defined?(::Rackup::Handler)
 rescue StandardError
 end

data/lib/up/ruby/server_cli.rb

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

data/lib/up/u_web_socket/cluster.rb

@@ -2,6 +2,7 @@
 require 'up/u_web_socket/server'
 
 %x{
+  const process = require('node:process');
   const cluster = require('node:cluster');
   const num_workers = require('node:os').availableParallelism();
 }
@@ -9,8 +10,8 @@ require 'up/u_web_socket/server'
 module Up
   module UWebSocket
     class Cluster < Up::UWebSocket::Server
-      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, workers: nil)
-        super(app: app, host: host, port: port, scheme: scheme, ca_file: ca_file, cert_file: cert_file, key_file: key_file)
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR), workers: nil)
+        super(app: app, host: host, port: port, scheme: scheme, ca_file: ca_file, cert_file: cert_file, key_file: key_file, logger: logger)
         @workers = workers || `num_workers`
         @members = []
       end
@@ -19,10 +20,24 @@ module Up
         raise "already running" unless @members.empty?
         %x{
           if (cluster.isPrimary) {
+            cluster.on('message', (worker, message, handle) => {
+              if (message.c && message.m) {
+                for (let member of #@members) {
+                  if (member !== worker) {
+                    member.send(message);
+                  }
+                }
+              }
+            });
             for (let i = 0; i < #@workers; i++) {
-              #@members.push(cluster.fork());
+              #@members[i] = cluster.fork();
             }
           } else {
+            self.worker = true;
+            function process_message_handler(message, handle) {
+              self.server.publish(message.c, message.m);
+            }
+            process.on('message', process_message_handler);
             #{super}
           }
         }

data/lib/up/u_web_socket/server.rb

@@ -1,8 +1,10 @@
 # backtick_javascript: true
+require 'logger'
 require 'up/cli'
-require 'up/u_web_socket/rack_env'
+require 'up/client'
 
 %x{
+  const process = require('node:process');
   module.paths.push(process.cwd() + '/node_modules');
   const uws = require('uWebSockets.js');
 }
@@ -10,32 +12,32 @@ require 'up/u_web_socket/rack_env'
 module Up
   module UWebSocket
     class Server
-      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil)
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil, logger: Logger.new(STDERR))
         @app = app
         @scheme    = scheme || 'http'
         raise "unsupported scheme #{@scheme}" unless %w[http https].include?(@scheme)
         @host      = host || 'localhost'
         @port      = port&.to_i || 3000
-        @config    = { handler: self.class.name, engine: "node/#{`process.version`}", port: port, scheme: scheme, host: host }.freeze
+        @config    = { handler: self.class.name, engine: "node/#{`process.version`}" }.freeze
         @ca_file   = ca_file
         @cert_file = cert_file
         @key_file  = key_file
-        @server = nil
+        @default_input = IO.new
+        @server    = nil
+        @logger    = logger
+        @t_factory = proc { |filename, _content_type| File.new(filename, 'a+') }
       end
 
       %x{
         self.handle_headers = function(rack_headers, uws_res) {
           if (rack_headers.$$is_hash) {
-            var header, k, v;
+            var header, v;
             for(header of rack_headers) {
-              k = header[0];
-              if (!k.startsWith('rack.')) {
-                v = header[1];
-                if (v.$$is_array) {
-                  v = v.join("\n");
-                }
-                uws_res.writeHeader(k, v);
+              v = header[1];
+              if (v.$$is_array) {
+                v = v.join("\n");
               }
+              uws_res.writeHeader(header[0].toLowerCase(), v);
             }
           }
         }
@@ -48,25 +50,116 @@ module Up
           }
           #{`parts`.close if `parts`.respond_to?(:close)}
         }
+
+        self.prepare_env = function(req) {
+          const env = new Map();
+          env.set('rack.errors',#{STDERR});
+          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);
+          env.set('rack.url_scheme', #@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('REQUEST_METHOD', req.getMethod().toUpperCase());
+          env.set('PATH_INFO', req.getUrl());
+          req.forEach((k, v) => { env.set('HTTP_' + k.toUpperCase().replaceAll('-', '_'), v) });
+          return env;
+        }
       }
 
       def listen
         raise "already running" if @server
         %x{
-          const ouwr = Opal.Up.UWebSocket.RackEnv;
           const ouws = Opal.Up.UWebSocket.Server;
+          const ouwc = Opal.Up.Client;
+          const deco = new TextDecoder();
           if (#@scheme == 'https') {
             #@server = uws.SSLApp({ ca_file_name: #@ca_file, cert_file_name: #@cert_file, key_file_name: #@key_file });
           } else {
             #@server = uws.App();
           }
           #@server.any('/*', (res, req) => {
-            const rack_res = #@app.$call(ouwr.$new(req, #@config));
-            res.writeStatus(`${rack_res[0].toString()} OK`);
+            const rack_res = #@app.$call(ouws.prepare_env(req));
+            res.writeStatus(rack_res[0].toString() + ' OK');
             ouws.handle_headers(rack_res[1], res);
             ouws.handle_response(rack_res[2], res);
             res.end();
           });
+          #@server.ws('/*', {
+            close: (ws, code, message) => {
+              const user_data = ws.getUserData();
+              if (typeof(user_data.client.handler.$on_close) === 'function') {
+                user_data.client.ws = ws;
+                user_data.client.open = false;
+                user_data.client.handler.$on_close(user_data.client);
+                user_data.client.ws = null;
+              }
+            },
+            drain: (ws) => {
+              const user_data = ws.getUserData();
+              if (typeof(user_data.client.handler.$on_drained) === 'function') {
+                user_data.client.ws = ws;
+                user_data.client.handler.$on_drained(user_data.client);
+                user_data.client.ws = null;
+              }
+            },
+            message: (ws, message, isBinary) => {
+              const user_data = ws.getUserData();
+              if (typeof(user_data.client.handler.$on_message) === 'function') {
+                const msg = deco.decode(message);
+                user_data.client.ws = ws;
+                user_data.client.handler.$on_message(user_data.client, msg);
+                user_data.client.ws = null;
+              }
+            },
+            open: (ws) => {
+              const user_data = ws.getUserData();
+              if (typeof(user_data.client.handler.$on_open) === 'function') {
+                user_data.client.ws = ws;
+                user_data.client.open = true;
+                user_data.client.handler.$on_open(user_data.client);
+                user_data.client.ws = null;
+              }
+            },
+            sendPingsAutomatically: true,
+            upgrade: (res, req, context) => {
+              const env = ouws.prepare_env(req);
+              env.set('rack.upgrade?', #{:websocket});
+              const rack_res = #@app.$call(env);
+              const handler = env.get('rack.upgrade');
+              if (rack_res[0] < 300 && handler && handler !== nil) {
+                const client = ouwc.$new();
+                client.env = env;
+                client.open = false;
+                client.handler = handler
+                client.protocol = #{:websocket};
+                client.server = self.server;
+                client.timeout = 120;
+                if (self.worker) {
+                  client.worker = true;
+                }
+                res.upgrade({ client: client },
+                  req.getHeader('sec-websocket-key'),
+                  req.getHeader('sec-websocket-protocol'),
+                  req.getHeader('sec-websocket-extensions'),
+                  context);
+              } else {
+                if (rack_res[0] >= 300) {
+                  env.delete('rack.upgrade');
+                }
+                res.writeStatus(rack_res[0].toString() + ' OK');
+                ouws.handle_headers(rack_res[1], res);
+                ouws.handle_response(rack_res[2], res);
+                res.end();
+              }
+            },
+
+          });
           #@server.listen(#@port, #@host, () => { console.log(`Server is running on ${#@scheme}://${#@host}:${#@port}`)});
         }
       end

data/lib/up/version.rb

@@ -1,3 +1,3 @@
 module Up
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.4'.freeze
 end