isomorfeus-iodine 0.7.50 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f6d52427fb6c73c781981a09b9217b557e2da7c676578d7c726c375f8f49919
-  data.tar.gz: 24b2b507bb66405986b947085fcc6ac65d921fb3e7775ffb00ea82909cfc74fb
+  metadata.gz: e1da68cfbc32b4125c4ca8513b8796276b1ea4daa2123517a5fa3ed895ebddf0
+  data.tar.gz: 1cc64c512e725ca4e7fb119c9bc59f2ac6d4edc59ae99e2ca7c4a74beb8fd9de
 SHA512:
-  metadata.gz: '059aafd0ed382cc2b7446532d83a19121e19e61c8c9590bf372d074149aee2765426452c488020a2b55720fc63fbf050cc4314e26398495945957d55b9328a8c'
-  data.tar.gz: e0e74b28d8f2c193271aa8a610298f003913e0214870ca2dd20d4c87a7358da04bd63015204788eabbe84215f4c89582f85f2d1bb4504773e8b46776d744ae3b
+  metadata.gz: a04d7a8b0edd83ce7bbb130a43b4655ea0b271ffc99c3d2bd265763899335569ee23abdae992e4082c902989817ded91d5ac529513bb089c5a66e34c984b7daf
+  data.tar.gz: 73dc8cbc81472fb1dacdf38f71cdd75107b8641d64a6f4d0834fa8e7f60126852a767ac64a25d0ca85403cee2d0e80b1fb40f4f24d53210627d1f7c378b3f9a7

data/Rakefile

@@ -27,7 +27,6 @@ task :push do
   system("git push github")
   system("git push gitlab")
   system("git push bitbucket")
-  system("git push gitprep")
 end
 
 task :default => [:compile, :spec]

data/examples/config.ru

@@ -1,56 +1,56 @@
-# This is a WebSocket / SSE notification broadcasting application.
-#
-# Running this application from the command line is easy with:
-#
-#      iodine
-#
-# Or, in single thread and single process:
-#
-#      iodine -t 1 -w 1
-#
-# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
-#
-#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
-#      wrk -c2000 -d5 -t12 http://localhost:3000/
-
-
-# A simple router - Checks for Websocket Upgrade and answers HTTP.
-module MyHTTPRouter
-  # This is the HTTP response object according to the Rack specification.
-  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
-          'Content-Length' => '77' },
-   ['Please connect using WebSockets or SSE (send messages only using WebSockets).']]
-
-  WS_RESPONSE = [0, {}, []].freeze
-
-   # this is function will be called by the Rack server (iodine) for every request.
-   def self.call env
-     # check if this is an upgrade request (WebsSocket / SSE).
-     if(env['rack.upgrade?'.freeze])
-       env['rack.upgrade'.freeze] = BroadcastClient
-       return WS_RESPONSE
-     end
-     # simply return the RESPONSE object, no matter what request was received.
-     HTTP_RESPONSE
-   end
-end
-
-# A simple Websocket Callback Object.
-module BroadcastClient
-  # seng a message to new clients.
-  def on_open client
-    client.subscribe :broadcast
-  end
-  # send a message, letting the client know the server is suggunt down.
-  def on_shutdown client
-    client.write "Server shutting down. Goodbye."
-  end
-  # perform the echo
-  def on_message client, data
-    client.publish :broadcast, data
-  end
-  extend self
-end
-
-# this function call links our HelloWorld application with Rack
-run MyHTTPRouter
+# This is a WebSocket / SSE notification broadcasting application.
+#
+# Running this application from the command line is easy with:
+#
+#      iodine
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1
+#
+# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
+#
+#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
+#      wrk -c2000 -d5 -t12 http://localhost:3000/
+
+
+# A simple router - Checks for Websocket Upgrade and answers HTTP.
+module MyHTTPRouter
+  # This is the HTTP response object according to the Rack specification.
+  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '77' },
+   ['Please connect using WebSockets or SSE (send messages only using WebSockets).']]
+
+  WS_RESPONSE = [0, {}, []].freeze
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # check if this is an upgrade request (WebsSocket / SSE).
+     if(env['rack.upgrade?'.freeze])
+       env['rack.upgrade'.freeze] = BroadcastClient
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+module BroadcastClient
+  # seng a message to new clients.
+  def on_open client
+    client.subscribe :broadcast
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown client
+    client.write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message client, data
+    client.publish :broadcast, data
+  end
+  extend self
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/exe/iodine

@@ -1,277 +1,64 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-IODINE_PARSE_CLI = true
-require 'iodine'
-
-# 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
-      end
-    end
-  end
-rescue LoadError
-  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)
-            @run = app
-          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
-        end
-      end
-    end
-  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
-
-      def self.try_file filename
-        return nil unless File.exist? filename
-        return Iodine::Base::Rack::Builder.parse_file filename
-      end
-
-      def self.get_app_opts
-        app, opt = nil, nil
-        filename = Iodine::DEFAULT_SETTINGS[:filename_]
-        if filename
-          app, opt = try_file filename
-          app, opt = try_file "#{filename}.ru" unless opt
-          unless opt
-            puts "* Couldn't find #{filename}\n  testing for config.ru\n"
-            app, opt = try_file "config.ru"
-          end
-        else
-          app, opt = try_file "config.ru";
-        end
-
-        unless opt
-          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."
-            opt = Hash.new
-            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
-        end
-        return app, opt
-      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('/')
-            end
-          end
-        end
-      end
-
-      def self.call
-        app, opt = get_app_opts
-        perform_warmup(app) if Iodine::DEFAULT_SETTINGS[:warmup_]
-        Iodine::Rack.run(app, opt)
-      end
-    end
-  end
-end
-
-Iodine::Base::CLI.call
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+IODINE_PARSE_CLI = true
+require 'iodine'
+
+# Load Rack if available (assume it will be used)
+
+require 'rack'
+
+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
+
+      def self.try_file filename
+        return nil unless File.exist? filename
+        ::Rack::Builder.parse_file filename
+      end
+
+      def self.get_app
+        app = nil
+        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";
+        end
+        app
+      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
+          ::Rack::Builder.new(app) do |r|
+            r.warmup do |a|
+              client = ::Rack::MockRequest.new(a)
+              client.get('/')
+            end
+          end
+        end
+      end
+
+      def self.call
+        app = get_app
+        perform_warmup(app) if Iodine::DEFAULT_SETTINGS[:warmup_]
+        Iodine::Rack.run(app)
+      end
+    end
+  end
+end
+
+Iodine::Base::CLI.call

data/ext/iodine_ext/fio.c

@@ -155,7 +155,7 @@ int ioctl (int fd, u_long request, int* argp) {
   else { return 0; }
 }
 
-int kill(int pid, int sig) {
+int fio_kill(int pid, int sig) {
   /* Credit to Jan Biedermann (GitHub: @janbiedermann) */
   HANDLE handle;
   DWORD status;
@@ -987,7 +987,7 @@ FIO_FUNC void fio_thread_signal(void) {
     (void)r;
   } else if (fd == -1) {
     /* hardly the best way, but there's a thread sleeping on air */
-    kill(getpid(), SIGCONT);
+    fio_kill(getpid(), SIGCONT);
   }
 #endif
 }
@@ -1654,7 +1654,7 @@ void fio_reap_children(void) {
   sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
   if (sigaction(SIGCHLD, &sa, &fio_old_sig_chld) == -1) {
     perror("Child reaping initialization failed");
-    kill(0, SIGINT);
+    fio_kill(0, SIGINT);
     exit(errno);
   }
 }
@@ -4603,7 +4603,7 @@ static void *fio_sentinel_worker_thread(void *arg) {
   if (child == -1) {
     FIO_LOG_FATAL("couldn't spawn worker.");
     perror("\n           errno");
-    kill(fio_parent_pid(), SIGINT);
+    fio_kill(fio_parent_pid(), SIGINT);
     fio_stop();
     return NULL;
   } else if (child) {
@@ -4617,7 +4617,7 @@ static void *fio_sentinel_worker_thread(void *arg) {
       } else {
         FIO_LOG_FATAL("Child worker (%d) shutdown. Stopping services.", child);
       }
-      kill(0, SIGINT);
+      fio_kill(0, SIGINT);
     }
 #else
     if (fio_data->active) {
@@ -6879,7 +6879,7 @@ static void fio_cluster_on_close(intptr_t uuid, fio_protocol_s *pr_) {
 #ifndef __MINGW32__
       fio_cluster_data_cleanup(1);
 #endif
-      kill(getpid(), SIGINT);
+      fio_kill(getpid(), SIGINT);
     }
   }
   if (c->msg)
@@ -7155,7 +7155,7 @@ static void fio_cluster_on_connect(intptr_t uuid, void *udata) {
 static void fio_cluster_on_fail(intptr_t uuid, void *udata) {
   FIO_LOG_FATAL("(facil.io) unknown cluster connection error");
   perror("       errno");
-  kill(fio_parent_pid(), SIGINT);
+  fio_kill(fio_parent_pid(), SIGINT);
   fio_stop();
   // exit(errno ? errno : 1);
   (void)udata;

data/ext/iodine_ext/fio.h

@@ -263,10 +263,12 @@ Version and helper macros
 #define pipe(fds) _pipe(fds, 65536, _O_BINARY)
 
 int fork(void);
-int kill(int, int);
+int fio_kill(int, int);
 ssize_t pread(int, void*, size_t, off_t);
 ssize_t pwrite(int, const void *, size_t, off_t);
 int fio_osffd4fd(unsigned int);
+#else
+#define fio_kill kill
 #endif
 
 /* *****************************************************************************
@@ -523,7 +525,7 @@ FIO_LOG2STDERR(const char *format, ...) {
   if (!(ptr)) {                                                                \
     FIO_LOG_FATAL("memory allocation error "__FILE__                           \
                   ":" FIO_MACRO2STR(__LINE__));                                \
-    kill(0, SIGINT);                                                           \
+    fio_kill(0, SIGINT);                                                           \
     exit(errno);                                                               \
   }
 #endif
@@ -6048,7 +6050,7 @@ FIO_NAME(_insert_or_overwrite_)(FIO_NAME(s) * set, FIO_SET_HASH_TYPE hash_value,
   pos->hash = hash_value;
   pos->pos->hash = hash_value;
   FIO_SET_COPY(pos->pos->obj, obj);
-  
+
   return pos->pos->obj;
 }
 

data/ext/iodine_ext/http.c

@@ -922,7 +922,7 @@ intptr_t http_listen(const char *port, const char *binding,
   if (arg_settings.on_request == NULL) {
     FIO_LOG_ERROR("http_listen requires the .on_request parameter "
                   "to be set\n");
-    kill(0, SIGINT);
+    fio_kill(0, SIGINT);
     exit(11);
   }
 

data/ext/iodine_ext/redis_engine.c

@@ -852,7 +852,7 @@ FIO_IGNORE_MACRO(struct redis_engine_create_args args) {
   if (getpid() != fio_parent_pid()) {
     FIO_LOG_FATAL("(redis) Redis engine initialization can only "
                   "be performed in the Root process.");
-    kill(0, SIGINT);
+    fio_kill(0, SIGINT);
     fio_stop();
     return NULL;
   }

data/isomorfeus-iodine.gemspec

@@ -34,6 +34,8 @@ Gem::Specification.new do |spec|
   spec.requirements << 'TLS requires OpenSSL >= 1.1.0.'
   spec.requirements << 'Or Windows with Ruby >= 3.0.0 build with MingW and MingW as compiler.'
 
+  spec.add_dependency 'rackup', '~> 0.2.2'
+  spec.add_dependency 'rack', '~> 3.0.0'
   spec.add_development_dependency 'rake', '~> 13.0', '< 14.0'
   spec.add_development_dependency 'minitest', '>=5', '< 6.0'
   spec.add_development_dependency 'rspec', '>=3.9.0', '< 4.0'

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.50'.freeze
+  VERSION = '0.8.1'.freeze
 end

data/lib/rack/handler/iodine.rb

@@ -1,33 +1,35 @@
-require 'iodine' unless defined?(::Iodine::VERSION)
-
-module Iodine
-  # Iodine's {Iodine::Rack} module provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
-  module Rack
-
-    # Runs a Rack app, as par the Rack handler requirements.
-    def self.run(app, options = {})
-      # nested applications... is that a thing?
-      Iodine.listen(service: :http, handler: app, port: options[:Port], address: options[:Host])
-
-      # start Iodine
-      Iodine.start
-
-      true
-    end
-
-    # patches an assumption by Rack, issue #98 code donated by @Shelvak (Néstor Coppi)
-    def self.shutdown
-      Iodine.stop
-    end
-
-    IODINE_RACK_LOADED = true
-  end
-end
-
-ENV['RACK_HANDLER'] ||= 'iodine'
-
-begin
-  ::Rack::Handler.register('iodine', 'Iodine::Rack') if defined?(::Rack::Handler)
-  ::Rack::Handler.register('Iodine', 'Iodine::Rack') if defined?(::Rack::Handler)
-rescue StandardError
-end
+require 'iodine' unless defined?(::Iodine::VERSION)
+
+module Iodine
+  # Iodine's {Iodine::Rack} module provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
+  module Rack
+
+    # Runs a Rack app, as par the Rack handler requirements.
+    def self.run(app, options = {})
+      # nested applications... is that a thing?
+      Iodine.listen(service: :http, handler: app, port: options[:Port], address: options[:Host])
+
+      # start Iodine
+      Iodine.start
+
+      true
+    end
+
+    # patches an assumption by Rack, issue #98 code donated by @Shelvak (Néstor Coppi)
+    def self.shutdown
+      Iodine.stop
+    end
+
+    IODINE_RACK_LOADED = true
+  end
+end
+
+ENV['RACK_HANDLER'] ||= 'iodine'
+
+begin
+  if defined?(::Rackup::Handler)
+    ::Rackup::Handler.register('iodine', Iodine::Rack)
+    ::Rackup::Handler.register('Iodine', Iodine::Rack)
+  end
+rescue StandardError
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.50
+  version: 0.8.1
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-28 00:00:00.000000000 Z
+date: 2022-10-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -247,7 +275,7 @@ metadata:
   github_repo: ssh://github.com/isomorfeus/gems
   source_code_uri: https://github.com/isomorfeus/isomorfeus-iodine
 post_install_message: |-
-  Thank you for installing Iodine 0.7.50.
+  Thank you for installing Iodine 0.8.1.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations) to Bo, see https://github.com/boazsegev/iodine
 rdoc_options: []
 require_paths:
@@ -270,7 +298,7 @@ requirements:
 - Ruby >= 2.5.0 recommended.
 - TLS requires OpenSSL >= 1.1.0.
 - Or Windows with Ruby >= 3.0.0 build with MingW and MingW as compiler.
-rubygems_version: 3.3.7
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: iodine build for Isomorfeus