opal-up 0.0.1 → 0.0.3

data/lib/up/bun/server.rb

@@ -0,0 +1,89 @@
+# backtick_javascript: true
+require 'up/cli'
+require 'up/bun/rack_env'
+
+module Up
+  module Bun
+    class Server
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil)
+        @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
+        @ca_file   = ca_file
+        @cert_file = cert_file
+        @key_file  = key_file
+        @server = nil
+      end
+
+      %x{
+        self.handle_headers = function(rack_headers, bun_hdr) {
+          if (rack_headers.$$is_hash) {
+            var header, k, 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);
+              }
+            }
+          }
+        }
+
+        self.handle_response = function(parts, body) {
+          if (parts["$respond_to?"]('each')) {
+            // this is not technically correct, just to make things work
+            #{`parts`.each { |part| `body = body + part` }}
+          } else if (parts["$respond_to?"]('call')) {
+            body = parts.$call();
+          }
+          #{`parts`.close if `parts`.respond_to?(:close)}
+          return body;
+        }
+      }
+      def listen
+        raise "already running" if @server
+        %x{
+          const oubr = Opal.Up.Bun.RackEnv;
+          const oubs = Opal.Up.Bun.Server;
+
+          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]);
+              var body = '';
+              body = oubs.handle_response(rack_res[2], body);
+              return new Response(body, {status: rack_res[0], statusText: 'OK', headers: hdr});
+            }
+          };
+          if (#@scheme === 'https') {
+            server_options.tls = {
+              key: Bun.file(#@key_file),
+              cert: Bun.file(#@cert_file),
+              ca: Bun.file(#@ca_file)
+            };
+          }
+      
+          #@server = Bun.serve(server_options);
+          console.log(`Server is running on ${#@scheme}://${#@host}:${#@port}`);
+        }
+      end
+
+      def stop
+        if Up::CLI::stoppable?
+          `#@server.stop()`
+          @server = nil
+        end
+      end
+    end
+  end
+end

data/lib/up/bun/server_cli.rb

@@ -0,0 +1,15 @@
+require 'opal/platform'
+require 'bun/file'
+require 'nodejs/require'
+require 'opal-parser'
+require 'rack/builder'
+require 'up/rack_builder_patch'
+require 'up/bun/rack_server'
+
+module Up
+  module CLI
+    def self.call
+      Up::Bun::RackServer.run(get_app, get_options)
+    end
+  end
+end

data/lib/up/cli.rb

@@ -0,0 +1,151 @@
+require 'optparse'
+require 'up/version'
+
+module Up
+  module CLI
+    class Options < OptionParser
+      attr_reader :options
+      def initialize
+        super
+        @options = {}
+        self.banner = 'Usage: up [options]'
+        separator ''
+        on('-h', '--help', 'Show this message') do
+          puts self
+          exit
+        end
+        on('-p', '--port PORT', String, 'Port number the server will listen to') do |port|
+          options[:port] = port.to_i
+        end
+        on('-b', '--bind ADDRESS', String, 'Address the server will listen to') 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
+          options[:scheme] = 'https'
+        end
+        on('-a', '--ca-file FILE', String, 'File with CA certs') do |ca_file|
+          options[:ca_file] = ca_file
+        end
+        on('-c', '--cert-file FILE', String, 'File with the servers certificate') do |cert_file|
+          options[:cert_file] = cert_file
+        end
+        on('-k', '--key-file FILE', String, 'File with the servers certificate') do |key_file|
+          options[:key_file] = key_file
+        end
+        on('-v', '--version', 'Show version') do
+          puts "Up! v#{Up::VERSION}"
+          exit
+        end
+      end
+
+      def parse!
+        super
+        if options[:scheme] == 'https'
+          if !options[:ca_file] || !options[:cert_file] || !options[:key_file]
+            puts "When using -s or --secure the -a,-c- and -k options must be given too!"
+            exit 2
+          end
+        end
+      end
+    end
+
+    class << self
+      if RUBY_ENGINE != 'opal'
+        def setup_bun
+          bun_cmd = `which bun`
+          if !bun_cmd || bun_cmd.empty?
+            puts "Please install bun first!"
+            exit 2
+          end
+          true
+        end
+          
+        def setup_node
+          node_cmd = `which node`
+          if !node_cmd || node_cmd.empty?
+            puts "Please install node first!"
+            exit 2
+          end
+          true
+        end
+
+        def setup_u_web_socket
+          setup_node
+          npm_cmd = `which npm`
+          if !npm_cmd || npm_cmd.empty?
+            puts "Please install npm first!"
+            exit 2
+          end
+          npm_cmd.chop! if npm_cmd.end_with?("\n")
+          have_uws = `npm list|grep uWebSockets.js@20`
+          `npm i uNetworking/uWebSockets.js#v20.41.0` if have_uws.empty?
+          true
+        end
+      end
+
+      def get_options
+        options = Up::CLI::Options.new
+        options.parse!
+        options.options
+      rescue OptionParser::InvalidOption => e
+        $stderr.puts "#{$0}: #{e.message} (-h will show valid options)"
+        exit 64
+      end
+
+      def get_gems_for_cmd
+        # Opal does not yet support gems, so lets read the Gemfile and simply add each gem
+        # to the Opal load path and require it, works for some gems, fails for others
+        gems = ""
+        if File.exist?("Gemfile")
+          lines = File.readlines('Gemfile')
+          lines.each do |line|
+            m = /gem ['"](\w+)['"]/.match(line)
+            gems << " -g #{m[1]} -r #{m[1]}" if m && m[1] != 'opal-up'
+          end
+        end
+        gems
+      end
+
+      def try_file(filename)
+        return nil unless File.exist? filename
+        ::Rack::Builder.parse_file filename
+      end
+
+      def get_app(filename = 'config.ru')
+        app = nil
+        filename ||= 'config.ru'
+        app = try_file(filename)
+        unless app
+          filename = "#{filename}.ru"
+          app = try_file(filename)
+        end
+        raise "Something wrong with #{filename}\n" unless app
+        app
+      end
+
+      def stoppable?
+        sleep 0.1
+        puts 'deflating request chain links'
+        sleep 0.1
+        puts 'optimizing response distortion'
+        sleep 0.1
+        print 'releasing boost pressure: '
+        3.times do
+          sleep 0.2
+          print '.'
+        end
+        3.times do 
+          puts "\n\033[5;31;47mRED ALERT: boost pressure to high, cannot open release valve!1!!!\033[0m"
+          sleep 0.1
+          print '.'
+          sleep 0.1
+        end
+        puts 'stopping engines failed, for further help see:'
+        puts 'https://www.youtube.com/watch?v=ecBco63zvas'
+        sleep 0.2
+        puts "Just kidding :)"
+        true
+      end
+    end
+  end
+end

data/lib/up/node/cluster.rb

@@ -0,0 +1,39 @@
+# backtick_javascript: true
+require 'up/node/server'
+
+%x{
+  const cluster = require('node:cluster');
+  const num_workers = require('node:os').availableParallelism();
+}
+
+module Up
+  module Node
+    class Cluster < Up::Node::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)
+        @workers = workers || `num_workers`
+        @members = []
+      end
+
+      def listen
+        raise "already running" unless @members.empty?
+        %x{
+          if (cluster.isPrimary) {
+            for (let i = 0; i < #@workers; i++) {
+              #@members.push(cluster.fork());
+            }
+          } else {
+            #{super}
+          }
+        }
+      end
+
+      def stop
+        if Up::CLI::stoppable?
+          @members.each { |m| `m.kill()` } 
+          @members.clear
+        end
+      end
+    end
+  end
+end

data/lib/up/node/cluster_cli.rb

@@ -0,0 +1,15 @@
+require 'opal/platform'
+require 'nodejs/file'
+require 'nodejs/require'
+require 'opal-parser'
+require 'rack/builder'
+require 'up/rack_builder_patch'
+require 'up/node/rack_cluster'
+
+module Up
+  module CLI
+    def self.call
+      Up::Node::RackCluster.run(get_app, get_options)
+    end
+  end
+end

data/lib/up/node/rack_cluster.rb

@@ -0,0 +1,25 @@
+require 'up/node/cluster'
+
+module Up
+  module Node
+    module RackCluster
+      def self.run(app, options = {})
+        raise "already running" if @server
+        @server = Up::Node::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::Node::RackCluster) if defined?(::Rackup::Handler)
+rescue StandardError
+end

data/lib/up/node/rack_env.rb

@@ -0,0 +1,106 @@
+# backtick_javascript: true
+
+require 'logger'
+require 'up/version'
+
+module Up
+  module Node
+    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 HTTP_VERSION 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'
+                      ::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 'HTTP_VERSION'
+                      `#@req.httpVersion`
+                    when 'PATH_INFO'
+                      `#@req.url`
+                    when 'QUERY_STRING'
+                      nil
+                    when 'RACK_ERRORS'
+                      self['rack.errors']
+                    when 'RACK_LOGGER'
+                      self['rack.logger']
+                    when 'REQUEST_METHOD'
+                      `#@req.method`
+                    when 'SCRIPT_NAME'
+                      ""
+                    when 'SERVER_NAME'
+                      @config[:host]
+                    when 'SERVER_PORT'
+                      @config[:port].to_s
+                    when 'SERVER_PROTOCOL'
+                      ""
+                    when 'SERVER_SOFTWARE'
+                      "#{@config[:handler]}/#{Up::VERSION} #{@config[:engine]}"
+                    else
+                      if key.start_with?('HTTP_')
+                        key = key[5..].gsub(/_/, '-')
+                        `#@req.headers[key.toLowerCase()]`
+                      else
+                        nil
+                      end
+                    end
+      end
+
+      def req_headers
+        h = {}
+        %x{
+          var hdr, hds = #@req.headers;
+          for (hdr in hds) { h.set(hdr, hdrs[hdr]); }
+        }
+        h
+      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

data/lib/up/node/rack_server.rb

@@ -0,0 +1,25 @@
+require 'up/node/server'
+
+module Up
+  module Node
+    module RackServer
+      def self.run(app, options = {})
+        raise "already running" if @server
+        @server = Up::Node::Server.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::Node::RackServer) if defined?(::Rackup::Handler)
+rescue StandardError
+end

data/lib/up/node/server.rb

@@ -0,0 +1,84 @@
+# backtick_javascript: true
+require 'up/cli'
+require 'up/node/rack_env'
+
+%x{
+  module.paths.push(process.cwd() + '/node_modules');
+  const http = require('node:http');
+  const https = require('node:https');
+  const fs = require('node:fs');
+}
+
+module Up
+  module Node
+    class Server
+      def initialize(app:, host: 'localhost', port: 3000, scheme: 'http', ca_file: nil, cert_file: nil, key_file: nil)
+        @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
+        @ca_file   = ca_file
+        @cert_file = cert_file
+        @key_file  = key_file
+        @server = nil
+      end
+
+      %x{
+        self.handle_headers = function(rack_headers, srv_res) {
+          if (rack_headers.$$is_hash) {
+            var header, k, v;
+            for(header of rack_headers) {
+              k = header[0];
+              if (!k.startsWith('rack.')) {
+                v = header[1];
+                if (v.$$is_array) {
+                  v = v.join("\n");
+                }
+                srv_res.setHeader(k, v);
+              }
+            }
+          }
+        }
+
+        self.handle_response = function(parts, srv_res) {
+          if (parts["$respond_to?"]('each')) {
+            #{`parts`.each { |part| `srv_res.write(part)` }}
+          } else if (parts["$respond_to?"]('call')) {
+            srv_res.write(parts.$call());
+          }
+          #{`parts`.close if `parts`.respond_to?(:close)}
+        }
+      }
+
+      def listen
+        raise "already running" if @server
+        %x{
+          const ounr = Opal.Up.Node.RackEnv;
+          const ouns = Opal.Up.Node.Server;
+          function handler(req, res) {
+            const rack_res = #@app.$call(ounr.$new(req, #@config));
+            res.statusCode = rack_res[0];
+            ouns.handle_headers(rack_res[1], res);
+            ouns.handle_response(rack_res[2], res);
+            res.end();
+          }
+          if (#@scheme == 'https') {
+            #@server = https.createServer({ ca: fs.readFileSync(#@ca_file), cert: fs.readFileSync(#@cert_file), key: fs.readFileSync(#@key_file) }, handler);
+          } else {
+            #@server = http.createServer(handler);
+          }
+          #@server.listen(#@port, #@host, () => { console.log(`Server is running on ${#@scheme}://${#@host}:${#@port}`)});
+        }
+      end
+
+      def stop
+        if Up::CLI::stoppable?
+          `#@server.close()`
+          @server = nil
+        end
+      end
+    end
+  end
+end

data/lib/up/node/server_cli.rb

@@ -0,0 +1,15 @@
+require 'opal/platform'
+require 'nodejs/file'
+require 'nodejs/require'
+require 'opal-parser'
+require 'rack/builder'
+require 'up/rack_builder_patch'
+require 'up/node/rack_server'
+
+module Up
+  module CLI
+    def self.call
+      Up::Node::RackServer.run(get_app, get_options)
+    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/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