iodine 0.7.59 → 0.8.0

data/examples/routes.ru

@@ -0,0 +1,42 @@
+# This is a multi-route example using NeoRack vs Rack `map`
+
+class RouteApp
+	def initialize(name)
+		@response = [200, {}, "Hello #{name}"] 
+	end
+	def call(e)
+		@response
+	end
+end
+
+ROUTE_COUNT = 100
+BSET_CASE_FOR_TRI = true
+
+if BSET_CASE_FOR_TRI # best case
+	ROUTE_COUNT.times {|i| url = "/try_this_route-#{i}" ; map(url) { run RouteApp.new(url) } }
+	puts "\t test with:"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-0"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-#{ROUTE_COUNT / 2}"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-#{ROUTE_COUNT - 1}"
+else
+	ROUTE_COUNT.times {|i| url = "/#{i}-try_this_route" ; map(url) { run RouteApp.new(url) } }
+	puts "\t test with:"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/0-try_this_route"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/#{ROUTE_COUNT / 2}-try_this_route"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/#{ROUTE_COUNT - 1}-try_this_route"
+end
+
+run {[404, {}, nil]}
+
+
+#### Rails Approach
+# GET       /          => index
+# GET       /new       => new
+# POST      /          => create
+# GET       /:id       => show
+# GET       /:id/edit  => edit
+# PATCH/PUT /:id       => update
+# DELETE    /:id       => destroy
+# Historical?
+# POST      /:id       => update
+

data/exe/iodine

@@ -1,280 +1,240 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
-IODINE_PARSE_CLI = true
 require 'iodine'
+require 'pathname'
 
-# Load Rack if available (assume it will be used).
-#
-# Remember, code costs memory. Duplicating the Rack::Builder module and functions can be avoided.
-begin
-  require 'rack'
-  module Iodine
-    module Base
-      module Rack
-        Builder = ::Rack::Builder
+module Iodine
+  class Base
+    class NeoRackUp
+      module NOOPHandler
       end
-    end
-  end
-rescue LoadError
-  puts "WARNING: The gam `rack` wasn't loaded before iodine started loading the rack app, using custom loader."
-  module Iodine
-    module Base
-      module Rack
-        # The Rack::Builder code is used when Rack isn't available.
-        #
-        # The code was copied (with minor adjustments) from the Rack source code and is licensed under the MIT license.
-        # Copyright (C) 2007-2019 Leah Neukirchen <http://leahneukirchen.org/infopage.html>
-        #
-        # ====
-        #
-        # Rack::Builder implements a small DSL to iteratively construct Rack
-        # applications.
-        #
-        # Example:
-        #
-        #  require 'rack/lobster'
-        #  app = Rack::Builder.new do
-        #    use Rack::CommonLogger
-        #    use Rack::ShowExceptions
-        #    map "/lobster" do
-        #      use Rack::Lint
-        #      run Rack::Lobster.new
-        #    end
-        #  end
-        #
-        #  run app
-        #
-        # Or
-        #
-        #  app = Rack::Builder.app do
-        #    use Rack::CommonLogger
-        #    run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
-        #  end
-        #
-        #  run app
-        #
-        # +use+ adds middleware to the stack, +run+ dispatches to an application.
-        # You can use +map+ to construct a Rack::URLMap in a convenient way.
-        class Builder
-          # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
-          UTF_8_BOM = '\xef\xbb\xbf'
-
-          def self.parse_file(config, opts = Hash.new)
-            if config =~ /\.ru$/
-              return self.load_file(config, opts)
-            else
-              require config
-              app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
-              return app, {}
-            end
-          end
-
-          def self.load_file(path, options = Hash.new)
-            cfgfile = ::File.read(path)
-            cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
-
-            cfgfile.sub!(/^__END__\n.*\Z/m, '')
-            app = new_from_string cfgfile, path
-
-            return app, options
-          end
-
-          def self.new_from_string(builder_script, file = "(rackup)")
-            eval "Iodine::Base::Rack::Builder.new {\n" + builder_script + "\n}.to_app",
-              TOPLEVEL_BINDING, file, 0
-          end
-
-          def initialize(default_app = nil, &block)
-            @use, @map, @run, @warmup, @freeze_app = [], nil, default_app, nil, false
-            instance_eval(&block) if block_given?
-          end
-
-          def self.app(default_app = nil, &block)
-            self.new(default_app, &block).to_app
-          end
-
-          # Specifies middleware to use in a stack.
-          #
-          #   class Middleware
-          #     def initialize(app)
-          #       @app = app
-          #     end
-          #
-          #     def call(env)
-          #       env["rack.some_header"] = "setting an example"
-          #       @app.call(env)
-          #     end
-          #   end
-          #
-          #   use Middleware
-          #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-          #
-          # All requests through to this application will first be processed by the middleware class.
-          # The +call+ method in this example sets an additional environment key which then can be
-          # referenced in the application if required.
-          def use(middleware, *args, &block)
-            if @map
-              mapping, @map = @map, nil
-              @use << proc { |app| generate_map(app, mapping) }
-            end
-            @use << proc { |app| middleware.new(app, *args, &block) }
-          end
-
-          # Takes an argument that is an object that responds to #call and returns a Rack response.
-          # The simplest form of this is a lambda object:
-          #
-          #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-          #
-          # However this could also be a class:
-          #
-          #   class Heartbeat
-          #     def self.call(env)
-          #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-          #     end
-          #   end
-          #
-          #   run Heartbeat
-          def run(app = nil, &block)
-            raise ArgumentError, "Both app and block given!" if app && block_given?
-            @run = app || block
-          end
-
-          # Takes a lambda or block that is used to warm-up the application.
-          #
-          #   warmup do |app|
-          #     client = Rack::MockRequest.new(app)
-          #     client.get('/')
-          #   end
-          #
-          #   use SomeMiddleware
-          #   run MyApp
-          def warmup(prc = nil, &block)
-            @warmup = prc || block
-          end
-
-          # Creates a route within the application.
-          #
-          #   Rack::Builder.app do
-          #     map '/' do
-          #       run Heartbeat
-          #     end
-          #   end
-          #
-          # The +use+ method can also be used here to specify middleware to run under a specific path:
-          #
-          #   Rack::Builder.app do
-          #     map '/' do
-          #       use Middleware
-          #       run Heartbeat
-          #     end
-          #   end
-          #
-          # This example includes a piece of middleware which will run before requests hit +Heartbeat+.
-          #
-          def map(path, &block)
-            @map ||= {}
-            @map[path] = block
-          end
-
-          # Freeze the app (set using run) and all middleware instances when building the application
-          # in to_app.
-          def freeze_app
-            @freeze_app = true
-          end
-
-          def to_app
-            app = @map ? generate_map(@run, @map) : @run
-            fail "missing run or map statement" unless app
-            app.freeze if @freeze_app
-            app = @use.reverse.inject(app) { |a, e| e[a].tap { |x| x.freeze if @freeze_app } }
-            @warmup.call(app) if @warmup
-            app
-          end
-
-          def call(env)
-            to_app.call(env)
-          end
-
-          private
-
-          def generate_map(default_app, mapping)
-            mapped = default_app ? { '/' => default_app } : {}
-            mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
-            URLMap.new(mapped)
-          end
+      module MiddleWarePre__
+        def initialize(*args, &blk);                @app = args[0]; super; end
+      private
+        def method_missing(method_name, *arguments)
+            m = self.define_singleton_method(method_name) {|*args| @app.send(method_name, *args) }
+            m.call(*arguments)
         end
       end
-    end
-  end
-end
+      module MiddleWareDef__
+        def on_http(e);                     @app.on_http(e); end
+        def on_finish(e);                   @app.on_finish(e); end
+        def call(env);                      @app.call(env); end
+        def on_authenticate(e);             @app.on_authenticate(e); end
+        def on_authenticate_sse(e);         @app.on_authenticate_sse(e); end
+        def on_authenticate_websocket(e);   @app.on_authenticate_websocket(e); end
+        def on_open(e);                     @app.on_open(e); end
+        def on_message(e, data);            @app.on_message(e, data); end
+        def on_drained(e);                  @app.on_drained(e); end
+        def on_timeout(e);                  @app.on_timeout(e); end
+        def on_shutdown(e);                 @app.on_shutdown(e); end
+        def on_close(e);                    @app.on_close(e); end
+        def on_eventsource(e, message);     @app.on_eventsource(e, message); end
+        def on_eventsource_reconnect(e,id); @app.on_eventsource_reconnect(e,id); end
+      end
 
-module Iodine
-  # The Iodine::Base namespace is reserved for internal use and is NOT part of the public API.
-  module Base
-    # Command line interface. The Ruby CLI might be changed in future versions.
-    module CLI
+      UTF_8_BOM = "\xef\xbb\xbf"
 
-      def self.try_file filename
-        return nil unless File.exist? filename
-        result = Iodine::Base::Rack::Builder.parse_file filename
-        return result[0] if(result.is_a?(Array))
-        return result
+      # uses specified Middleware class.
+      def use(mw, *args, &block)
+        @middleware ||= []
+        mw.prepend ::Iodine::Base::NeoRackUp::MiddleWarePre__
+        mw.include ::Iodine::Base::NeoRackUp::MiddleWareDef__
+        @middleware <<[mw, args, block]
       end
-
-      def self.get_app_opts
-        app, opt = nil, Hash.new
-        filename = Iodine::DEFAULT_SETTINGS[:filename_]
-        if filename
-          app = try_file(filename)
-          app = try_file("#{filename}.ru") unless app
-          unless app
-            puts "* Couldn't find #{filename}\n  testing for config.ru\n"
-            app = try_file "config.ru"
-          end
-        else
-          app = try_file "config.ru";
+      # Maps a URL path to a specific NeoRack Application
+      #
+      # Accepts an optional block for nested URL mapping and middleware use.
+      def map(path, handler = nil, &block)
+        path = "/" if path.nil?
+        raise "`path` must be a String in a call to map(path)." unless path.is_a?(String)
+        @middleware ||= []
+        @app ||= nil
+        @map ||= {}
+        @path_prefix ||= "".dup
+        old_middleware = @middleware.dup
+        old_app = @app
+        old_path_prefix = @path_prefix.dup
+        # prevent excess '/' and ignore special '*' allowances
+        @path_prefix.slice!(0, @path_prefix.length - 2) if (@path_prefix[-1] == '*' && @path_prefix[-2] == '/')
+        @path_prefix.slice!(0, @path_prefix.length - 1) if (@path_prefix[-1] == '/')
+        @path_prefix << '/' unless (path[0] == '/')
+        @path_prefix << path
+        @app = handler
+        block.call if block
+        puts "WARNING: overwriting existing route mapping @ #{@path_prefix}" if(@map[@path_prefix])
+        @map[@path_prefix] = @app
+        @middleware = old_middleware
+        @app = old_app
+        @path_prefix = old_path_prefix
+      rescue Exception => e
+        err = e
+        @app = nil
+        Iodine.stop
+        raise e
+      end
+      # Makes the calling module into a NeoRack Resource handler.
+      def neorack_resource(*ha)
+        ha.each {|handler| Server.make_resource(handler) }
+      end
+      # Sets NeoRack application for the server to run.
+      def run(a = nil, &block)
+        a = block if(!a)
+        raise "`run` called more than once." if @app
+        raise "Missing either an application handler or a block for the `run` instruction." unless a
+        raise "Missing both `on_http(e)` and `call(env)` in provided App." unless (a.respond_to?(:on_http) || a.respond_to?(:call))
+        Iodine::Base.add_missing_handler_methods(a)
+        while(@middleware && !@middleware.empty?)
+          m = @middleware.pop
+          a = m[0].new(a, *m[1], &m[2])
         end
-
-        unless app
-          puts "WARNING: Ruby application not found#{ filename ? " - missing both #{filename} and config.ru" : " - missing config.ru"}."
-          if Iodine::DEFAULT_SETTINGS[:public]
-            puts "         Running only static file service."
-            app = Proc.new { [404, {}, "Not Found!"] }
-          else
-            puts "\nERROR: Couldn't run Ruby application, check command line arguments."
-            ARGV << "-?"
-            Iodine::Base::CLI.parse
-            exit(0);
-          end
+        @app = a
+      rescue Exception => e
+        err = e
+        @app = nil
+        Iodine.stop
+        raise e
+      end
+      # Returns either the NeoRack Application or the routing map (if using a map) to be used.
+      def app
+        @map ||= {}
+        @map['/'] ||= @app
+        @map
+      end
+      # validate name of Web Application configuration file.
+      def self.iodine___detect_filename
+        file_name = Iodine::Base::CLI.parse(true)[0];
+        if(!file_name || File.directory?(file_name))
+          file_name ||= './'
+          file_name += '/' unless file_name.end_with?('/')
+          defaults = ["#{file_name}config.ru", "#{file_name}config.nru"]
+          defaults.pop if Iodine::Base::CLI['-R']
+          file_name = nil;
+          defaults.each {|n| file_name = n if(File.exist?(n))}
+          file_name ||= defaults[-1]
         end
-        return app, opt
+        file_name = nil if(!File.exist?(file_name))
+        raise("Web App not found: #{(Iodine::Base::CLI[0].nil? || File.directory?(Iodine::Base::CLI[0])) ? "missing config.#{Iodine::Base::CLI['-R'] ? '' : 'n'}ru?" : "#{Iodine::Base::CLI[0]} not found"}") if (file_name.nil? && (!Iodine::Base::CLI[0].nil? || Iodine::Base::CLI['-www'].nil?))
+        file_name
       end
-
-      def self.perform_warmup(app)
-        # load anything marked with `autoload`, since autoload is niether thread safe nor fork friendly.
-        Iodine.on_state(:on_start) do
-          Module.constants.each do |n|
-            begin
-              Object.const_get(n)
-            rescue StandardError => _e
-            end
-          end
-          Iodine::Base::Rack::Builder.new(app) do |r|
-            r.warmup do |a|
-              client = ::Rack::MockRequest.new(a)
-              client.get('/')
+      def self.iodine___load_rack fn
+        return nil unless fn
+        return nil unless (Iodine::Base::CLI['-R'] || File.extname(fn) == '.ru')
+        begin
+          require 'rack'
+        rescue LoadError => e
+          return nil unless Iodine::Base::CLI['-R']
+          puts "ERROR: rack not installed."
+          puts "       iodine -R requires the rack gem to be installed.\n"
+          raise e
+        end
+        Iodine::Utils.monkey_patch ::Rack::Utils
+        app = ::Rack::Builder.parse_file(fn)
+        app = app[0] if(app.is_a?(Array)) # Rack 2.x vs. Rack 3.x
+        app = {'/' => app} if app
+      end
+      def self.iodine___load_neorack fn
+        return nil unless fn
+        cfgfile = ::File.read(fn)
+        cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
+        cfgfile.sub!(/^__END__\n.*\Z/m, '')
+        builder = self.new
+        builder.instance_eval(cfgfile, fn, 0)
+        builder.app
+      end
+      def self.iodine___load_app_code(listener, fn, root_pid)
+        err = "Web App not found (no `run`?) in #{fn}"
+        app = nil
+        if(fn)
+          begin
+            old_wd = Dir.getwd
+            fn_name = File.basename(fn)
+            Dir.chdir(File.dirname(fn))
+            require 'bundler/setup' if File.exist?('Gemfile') && !defined?(::Bundler)
+            app = ::Iodine::Base::NeoRackUp.iodine___load_rack(fn_name)
+            unless app || Iodine::Base::CLI['-R']
+              app = ::Iodine::Base::NeoRackUp.iodine___load_neorack(fn_name)
             end
+            Dir.chdir(old_wd)
+          rescue Exception => e
+            err = e
+            app = nil
           end
         end
+        unless !fn || app
+          Iodine.stop
+          Process.kill("TERM", root_pid)
+          raise(err)
+        end
+        if app && app.is_a?(Hash) && app['/']
+          app.each {|k,v| listener.map(k,v) }
+        elsif app
+          listener.map nil, app
+        else
+          puts "WARNING:  (#{Process.pid}) no App found."
+        end
       end
-
-      def self.call
-        app, opt = get_app_opts
-        perform_warmup(app) if Iodine::DEFAULT_SETTINGS[:warmup_]
-        Iodine::Rack.run(app, opt)
+      ### loads auto-detected configuration file (iodine.rb)
+      def self.iodine___load_conf(fn = "./")
+        old_wd = Dir.getwd
+        Dir.chdir(File.dirname(fn)) if(fn && File.dirname(fn))
+        conf = Iodine::Base::CLI['--config']
+        conf = (::Pathname.new(File.dirname(fn.to_s).to_s) + Iodine::Base::CLI['--config']).to_s if(!conf || !File.exist?(conf))
+        unless File.exist?(conf)
+          puts "* No configuration file found @ #{conf}"
+            Dir.chdir(old_wd)
+          return
+        end
+        puts "* Pre-loading configuration @ #{conf}"
+        load conf 
+        Dir.chdir(old_wd)
+      end
+      def self.iodine___start
+        fn = ::Iodine::Base::NeoRackUp.iodine___detect_filename
+        raise "No App and no Static File Service (-www) detected." if(fn.nil? && !Iodine::Base::CLI['-www'])
+        ### load configuration file
+        ::Iodine::Base::NeoRackUp.iodine___load_conf(fn)
+        puts "* Starting iodine @ #{fn ? fn : Iodine::Base::CLI['-www']}"
+        listener = Iodine.listen(nil, Iodine::Base::NeoRackUp::NOOPHandler)
+        root_pid = Process.pid
+        ### hot code reloading?
+        if Iodine::Base::CLI['-preload']
+          iodine___load_app_code(listener, fn, root_pid)
+        else
+          Iodine.on_state(:start) do
+            iodine___load_app_code(listener, fn, root_pid)
+          end
+        end
+        Iodine.start
       end
     end
   end
 end
 
-Iodine::Base::CLI.call
+### .pid file
+if Iodine::Base::CLI['-pid']
+  pid_filename = Iodine::Base::CLI['-pid']
+  pid_filename << "iodine.pid" if(pid_filename[-1] == '/')
+  if File.exist?(pid_filename)
+    raise "pid filename should point to a valid file name (not a folder)!" if(!File.file?(pid_filename))
+    raise "pid filename error! (doesn't end with .pid)" if(File.extname(pid_filename) != '.pid')
+    File.delete(pid_filename)
+  end
+  Iodine.on_state(:pre_start) do
+    IO.binwrite(pid_filename, "#{Process.pid}\r\n")
+  end
+  Iodine.on_state(:exit) do
+    File.delete(pid_filename)
+  end
+end
+### hot restarts 
+if Iodine::Base::CLI['-hr'] && Iodine::Base::CLI['-w'].to_i != 0
+  Iodine.run_after(Iodine::Base::CLI['-hr'] * 1000, -1) do
+    Iodine.master? ? Process.kill("USR1", Process.pid) : false
+  end
+end
+
+### Start
+Iodine::Base::NeoRackUp.iodine___start
+
+

data/ext/iodine/extconf.rb

@@ -1,110 +1,37 @@
 require 'mkmf'
-require 'fileutils'
 
-# Test polling
-def iodine_test_polling_support
-  iodine_poll_test_kqueue = <<EOS
-\#define _GNU_SOURCE
-\#include <stdlib.h>
-\#include <sys/event.h>
-int main(void) {
-  int fd = kqueue();
-}
-EOS
-
-  iodine_poll_test_epoll = <<EOS
-\#define _GNU_SOURCE
-\#include <stdlib.h>
-\#include <stdio.h>
-\#include <sys/types.h>
-\#include <sys/stat.h>
-\#include <fcntl.h>
-\#include <sys/epoll.h>
-int main(void) {
-  int fd = epoll_create1(EPOLL_CLOEXEC);
-}
-EOS
-
-  iodine_poll_test_poll = <<EOS
-\#define _GNU_SOURCE
-\#include <stdlib.h>
-\#include <poll.h>
-int main(void) {
-  struct pollfd plist[18];
-  memset(plist, 0, sizeof(plist[0]) * 18);
-  poll(plist, 1, 1);
-}
-EOS
-
-  # Test for manual selection and then TRY_COMPILE with each polling engine
-  if Gem.win_platform?
-    puts "skipping polling tests, using WSAPOLL on Windows"
-    $defs << "-DFIO_ENGINE_WSAPOLL"
-  elsif ENV['FIO_POLL']
-    puts "skipping polling tests, enforcing manual selection of: poll"
-    $defs << "-DFIO_ENGINE_POLL"
-  elsif ENV['FIO_FORCE_POLL']
-    puts "skipping polling tests, enforcing manual selection of: poll"
-    $defs << "-DFIO_ENGINE_POLL"
-  elsif ENV['FIO_FORCE_EPOLL']
-    puts "skipping polling tests, enforcing manual selection of: epoll"
-    $defs << "-DFIO_ENGINE_EPOLL"
-  elsif ENV['FIO_FORCE_KQUEUE']
-    puts "* Skipping polling tests, enforcing manual selection of: kqueue"
-    $defs << "-DFIO_ENGINE_KQUEUE"
-  elsif try_compile(iodine_poll_test_epoll)
-    puts "detected `epoll`"
-    $defs << "-DFIO_ENGINE_EPOLL"
-  elsif try_compile(iodine_poll_test_kqueue)
-    puts "detected `kqueue`"
-    $defs << "-DFIO_ENGINE_KQUEUE"
-  elsif try_compile(iodine_poll_test_poll)
-    puts "detected `poll` - this is suboptimal fallback!"
-    $defs << "-DFIO_ENGINE_POLL"
+# TLS backend selection:
+# - IODINE_USE_EMBEDDED_TLS=1 forces embedded TLS 1.3 as default
+# - Otherwise, OpenSSL is used if available and compatible
+begin
+  dir_config('openssl')
+  if ENV['IODINE_USE_EMBEDDED_TLS']
+    puts '* Default TLS: embedded (fio_tls13) - forced by IODINE_USE_EMBEDDED_TLS'
+  elsif have_library('crypto') && have_library('ssl')
+    require 'openssl'
+    if OpenSSL::VERSION.to_i > 2
+      puts "* Detected OpenSSL version >= 3 (#{OpenSSL::VERSION}), setting the HAVE_OPENSSL flag."
+      $defs << '-DHAVE_OPENSSL'
+    else
+      puts "* OpenSSL version incompatible (#{OpenSSL::VERSION}), using embedded TLS 1.3"
+    end
   else
-    puts "* WARNING: No supported polling engine! expecting compilation to fail."
+    puts '* OpenSSL not found, using embedded TLS 1.3'
   end
+rescue StandardError => e
+  puts "* Couldn't find OpenSSL - using embedded TLS 1.3\n\t Err: #{e.message}"
 end
 
-iodine_test_polling_support()
+$defs << '-DDEBUG' if ENV['DEBUG']
 
-unless Gem.win_platform?
-  # Test for OpenSSL version equal to 1.0.0 or greater.
-  unless ENV['NO_SSL'] || ENV['NO_TLS'] || ENV["DISABLE_SSL"]
-    OPENSSL_TEST_CODE = <<EOS
-\#include <openssl/bio.h>
-\#include <openssl/err.h>
-\#include <openssl/ssl.h>
-\#if OPENSSL_VERSION_NUMBER < 0x10100000L
-\#error "OpenSSL version too small"
-\#endif
-int main(void) {
-  SSL_library_init();
-  SSL_CTX *ctx = SSL_CTX_new(TLS_method());
-  SSL *ssl = SSL_new(ctx);
-  BIO *bio = BIO_new_socket(3, 0);
-  BIO_up_ref(bio);
-  SSL_set0_rbio(ssl, bio);
-  SSL_set0_wbio(ssl, bio);
-}
-EOS
+append_cflags('-Wno-undef')
+append_cflags('-Wno-missing-noreturn')
 
-    dir_config("openssl")
-    begin
-      require 'openssl'
-    rescue LoadError
-    else
-      if have_library('crypto') && have_library('ssl')
-        puts "detected OpenSSL library, testing for version and required functions."
-        if try_compile(OPENSSL_TEST_CODE)
-          $defs << "-DHAVE_OPENSSL"
-          puts "confirmed OpenSSL to be version 1.1.0 or above (#{OpenSSL::OPENSSL_LIBRARY_VERSION})...\n* compiling with HAVE_OPENSSL."
-        else
-          puts "FAILED: OpenSSL version not supported (#{OpenSSL::OPENSSL_LIBRARY_VERSION} is too old)."
-        end
-      end
-    end
-  end
+# Windows requires crypt32 for cryptographic primitives used by the TLS backend
+# and bcrypt for the system CSPRNG (`BCryptGenRandom` in `fio_rand_bytes_secure`)
+if /mingw|mswin/ =~ RUBY_PLATFORM
+  $libs = append_library($libs, 'crypt32')
+  $libs = append_library($libs, 'bcrypt')
 end
 
-create_makefile 'iodine/iodine_ext'
+create_makefile 'iodine/iodine'