iodine 0.7.56 → 0.7.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2f42cc055212f19560dc49734f4ab9b4e0be6382172d5b9e7eed59791b88381
-  data.tar.gz: 2addb1393f4689b6dd0ab826c43a7dc9b0942e42fdc1ced57b153a910ef6e621
+  metadata.gz: 322c256e46337fbbb04715a5076984dda9e00ffa35e75bac7882fb8e95b17dea
+  data.tar.gz: 91390ce111e21fbf39f40e010bc059acab48d13a92b90f04d0a1a4b5738b87f8
 SHA512:
-  metadata.gz: 26cad762bc6d533c7a1828550a371b7db6107fae7439d02176eb02b70bd8887c8a30f7b1c68b931b2088aee728c7e098bbdbf9eec1cefcac697d31ccaf8ebe09
-  data.tar.gz: 7582b83233ce7ef198cc9a1d561b738396b5fe6d0b1701ba3984ec164735b3d8ce3fe3973481772217f7d580ec8b070d0493550859abfe0cbe03a5b8c9b6a738
+  metadata.gz: 78c783b0457ff798146af5c3040ccf86e3449dc33c53677986d58b7cd585745288bffcbf19f2427b8353c51507140b307209f33df2b4598d21d875c5203ab3a5
+  data.tar.gz: 257bbacb1c902bfa2202cd649b0d842f366963a528a00e115bc923a381d47bbe93e7c38c42cc21976f839d7a042873b107dc2fa8dd7ecc3703a61cecbe65e301

data/CHANGELOG.md

@@ -6,6 +6,16 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.58 (2024-04-28)
+
+**Fix**: possible fix for compilation issues on Fedora. Credit to @garytaylor for opening issue #155.
+
+**Fix**: possible fix for an OpenSSL certificate chain import issue that would cause certificate chains to be imported incorrectly. Credit to @dwolrdcojp for opening the facil.io repo PR #151.
+
+#### Change log v.0.7.57 (2023-09-04)
+
+**Fix**: Fixes possible name collision when loading gem (`.rb` vs. `.so` loading). Credit to @noraj (Alexandre ZANNI) for opening issue #148. Credit to @janbiedermann (Jan Biedermann) for discovering the root cause and offering a solution.
+
 #### Change log v.0.7.56 (2023-07-07)
 
 **Support**: Adds teapot support (HTTP code 418). Credit to Aleksandar N. Kostadinov (@akostadinov) for issue #144 and PR #145.

data/README.md

@@ -10,28 +10,28 @@
 
 Iodine is a fast concurrent web application server for real-time Ruby applications, with native support for WebSockets and Pub/Sub services - but it's also so much more.
 
-Iodine is a Ruby wrapper for many of the [facil.io](https://facil.io) C framework, leveraging the speed of C for many common web application tasks. In addition, iodine abstracts away all network concerns, so you never need to worry about the transport layer, free to concentrate on your application logic.
+Iodine is a Ruby wrapper for much of the [facil.io](https://facil.io) C framework, leveraging the speed of C for many common web application tasks. In addition, iodine abstracts away all network concerns, so you never need to worry about the transport layer, leaving you free to concentrate on your application logic.
 
 Iodine includes native support for:
 
 * HTTP, WebSockets and EventSource (SSE) Services (server);
 * WebSocket connections (server / client);
 * Pub/Sub (with optional Redis Pub/Sub scaling);
-* Fast(!) builtin Mustache template engine.
+* Fast(!) builtin Mustache templating;
 * Static file service (with automatic `gzip` support for pre-compressed assets);
-* Optimized Logging to `stderr`.
+* Optimized Logging to `stderr`;
 * Asynchronous event scheduling and timers;
 * HTTP/1.1 keep-alive and pipelining;
-* Heap Fragmentation Protection.
-* TLS 1.2 and above (Requires OpenSSL >= 1.1.0);
+* Heap Fragmentation Protection;
+* TLS 1.2 and above (Requiring OpenSSL >= 1.1.0);
 * TCP/IP server and client connectivity;
 * Unix Socket server and client connectivity;
-* Hot Restart (using the USR1 signal and without hot deployment);
+* Hot Restarts (using the USR1 signal and without hot deployment);
 * Custom protocol authoring;
-* [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection.
+* [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection;
 * and more!
 
-Since iodine wraps much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby:
+Since iodine wraps much of the [C facil.io framework](https://github.com/boazsegev/facil.io) for Ruby:
 
 * Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections on Linux)!
 
@@ -39,13 +39,13 @@ Since iodine wraps much of the [C facil.io framework](https://github.com/boazseg
 
 Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.3 and up... it should support the whole Ruby 2.x and 3.x MRI family, but CI tests start at Ruby 2.3.
 
-**Note**: iodine does **not** support streaming when using Rack. It's recommended to avoid blocking the server when using `body.each` since the `each` loop will block the iodine's thread until it's finished and iodine won't send any data before the loop is done.
+**Note**: iodine does **not** support streaming when using Rack. It's recommended to avoid blocking the server when using `body.each` since the `each` loop will block  iodine's thread until it's finished and iodine won't send any data before the loop is done.
 
 ## Iodine - a fast & powerful HTTP + WebSockets server with native Pub/Sub
 
 Iodine includes a light and fast HTTP and Websocket server written in C that was written according to the [Rack interface specifications](http://www.rubydoc.info/github/rack/rack/master/file/SPEC) and the [Websocket draft extension](./SPEC-Websocket-Draft.md).
 
-With `Iodine.listen service: :http` it's possible to run multiple HTTP applications (please remember not to set more than a single application on a single TCP/IP port). 
+With `Iodine.listen service: :http` it's possible to run multiple HTTP applications (but please remember not to set more than a single application on a single TCP/IP port). 
 
 Iodine also supports native process cluster Pub/Sub and a native RedisEngine to easily scale iodine's Pub/Sub horizontally.
 

data/examples/bates/README.md

@@ -0,0 +1,3 @@
+# Bates numbering with CombinePDF and Rack
+
+This folder holds a demo application combining Iodine's `X-Sendfile` support with the [`combine_pdf` gem](https://github.com/boazsegev/combine_pdf) to create a "bates numbering" tool that is common to the one used by some court systems (such as Israeli courts).

data/examples/bates/config.ru

@@ -0,0 +1,342 @@
+require 'combine_pdf'
+require 'rack'
+require 'base64'
+# require_relative 'pdf_controller'
+
+module BatesAPP
+  # This is the HTTP response object according to the Rack specification.
+  STATIC_RESPONSE = [200, { 'Content-Type' => 'text/html', 'X-Sendfile' => File.expand_path('./public/index.html') }.freeze, []].freeze
+  WS_RESPONSE = [403, { 'Content-Type' => 'text/html' }, "Forbidden"]
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+    req = Rack::Request.new(env)
+    # check if this is an upgrade request (WebsSocket / SSE).
+    return WS_RESPONSE if(env['rack.upgrade?'.freeze])
+    # simply return the RESPONSE object, no matter what request was received.
+    return STATIC_RESPONSE if req.params.empty?
+    return bates(req.params)
+   end
+
+
+  def self.bates(params)
+    params['file'] = params['file'].values # convert to Array
+    # catch any exception and tell the user which PDF caused the exception.
+    begin
+      # set the file_name variable
+      # this will be used in case an exception is caught
+      # to state which file caused the exception.
+      file_name = ''
+
+      # container for the complete pdf
+      # the complete pdf container will hold all
+      # the merged pdf data.
+      completed_pdf = CombinePDF.new
+
+      # get the output file name
+      # this will be used to name the download for the client's browser
+      output_name = params['bates']['output'].to_s + '.pdf'
+      output_name = "unknown.pdf" if output_name == '.pdf'
+
+      # get some paramaters that will be used while combining pages
+      params['bates'] ||= {}
+      first_page_number = params['bates']['first_page_number'].to_i
+      first_index_number = params['bates']['first_index_number'].to_i
+
+      # we will add an option for the stamping to ignore the first pdf
+      # this is useful for the court cases that use bates numbering
+      # (the "cover PDF" will be the briefs of submissions that contain exhibits to be bates stamped)
+      ignore_first_file = params['bates']['first_pdf_is_cover']
+      first_page = nil
+
+      # we will pick some data up while running combining the different pdf files.
+      # this will be used for the table of contents later on.
+      pdfs_pages_count = []
+      pdf_dates = []
+      pdf_titles = []
+
+      # we will be creating title pages before each PDF file.
+      # the title pages will be sized using the mediabox variable
+      # wich will be set with the dimentions of each pdf file's first page.
+      mediabox = nil
+
+      # register UNICODE fonts if necessary
+      # in this example I will register the Hebrew font David from an existing PDF file.
+      unless CombinePDF::Fonts.get_font :my_new_david
+        # if your running Rails, consider Rails.root instead of Root
+        fonts = CombinePDF.new(File.expand_path('./david+bold.pdf').to_s).fonts(true)
+        # I know the first font is David regular, after using the
+        # ruby console and looking at the fonts array for the file.
+        CombinePDF.register_font_from_pdf_object :my_new_david, fonts[0]
+        # the second font of the array was the latin font for a newline and space... useless
+        # the third was the david bold. I will now add that font.
+        CombinePDF.register_font_from_pdf_object :my_new_david_bold, fonts[2]
+      end
+
+      # iterate through the different files sent from the client's browser's web form
+      params['file'].each do |v|
+        # set the file_name variable in case an exception will be raised
+        file_name = v['name']
+
+        # parse the pdf data
+        # we will use the CombinePDF.parse method which allows us
+        # to parse data without saving the PDF to the file system.
+        # our javascript encoded the file data using base64, which we will need to decode.
+        # (this is specific to my form which uses the HTML5 File API in this specific manner)
+        # begin
+        puts "parsing file: #{file_name}"
+        pdf_file = CombinePDF.parse(
+          Base64.urlsafe_decode64(
+            v['data'].slice('data:application/pdf;base64,'.length,
+                           v['data'].length)
+          )
+        )
+        # rescue
+        #   puts "Failed when parsing #{file_name} with data:\n#{v['data'].inspect}"
+        #   raise
+        # end
+
+        # we will use the pages array a few times, so in order to avoid
+        # recomputing the array every time, we will save it to a local variable.
+        pdf_file_pages = pdf_file.pages
+
+        # we will add the page count to the page count array,
+        # used by the table of contents
+        pdfs_pages_count << pdf_file_pages.length
+
+        ######
+        # create and add title page to arrays.
+
+        if ignore_first_file && first_page.nil?
+          # if the first PDF file is a "cover page" PDF,
+          # we will not add a title, nor add the file.
+          # instead we will save the data in a variable to add it after we're done
+          pdf_dates << ''
+          pdf_titles << ''
+          first_page = pdf_file
+        else
+          # set title page mediabox size
+          # the mediabox data (page size) is contained in the page's
+          # :CropBox or :MediaBox keys (pages are Hash objects).
+          mediabox ||= pdf_file_pages[0][:CropBox] || pdf_file_pages[0][:MediaBox]
+
+          # create a title page unless we're only merging or there is no indexing
+          if params['bates']['should_index'] && params['bates']['numbering'] != 3
+
+            # create an empty page object
+            title_page = CombinePDF.create_page mediabox
+
+            # write the content to the title page.
+            # we will be using the I18n.t shortcut to write some of the data.
+            # the rest of the data, like the title, we got from the form.
+            title_page.textbox("#{params['bates']['title_type']} #{pdfs_pages_count.length + first_index_number - (ignore_first_file ? 2 : 1)}",
+                               max_font_size: 34,
+                               font: :my_new_david,
+                               y: (mediabox[3] - mediabox[1]) / 2) unless params['bates']['title_type'].to_s.empty?
+            title_page.textbox v['title'].to_s, max_font_size: 36, font: :my_new_david_bold
+            title_page.textbox v['date'].to_s, max_font_size: 24, font: :my_new_david, height: (mediabox[3] - mediabox[1]) / 2
+
+            # we will add the page object to the completed pdf object.
+            # notice that page objects are created as "floating" pages,
+            # not attached to any specific PDF file/object.
+            completed_pdf << title_page
+
+            # we will add some data that will be used to create the
+            # table of contents at a later stage.
+            page_count = pdfs_pages_count.pop + 1
+            pdfs_pages_count << page_count
+            pdf_dates << v['date'].to_s
+            pdf_titles << v['title'].to_s
+          end
+
+          # now we are ready to add the pdf file data to the completed pdf object.
+          # there is no need to add each page, we can add the pdf as a whole.
+          # (it's actually faster, as the PDF page catalog isn't recomputed for each page)
+          completed_pdf << pdf_file
+        end
+      end
+
+      ##########
+      # create the index pdf...
+      # ...unless we're only merging or there is no indexing
+      if params['bates']['should_index'] && params['bates']['numbering'].to_i != 3
+
+        # set the fonts and formatting for the table of contents.
+        #
+        # also, add an empty array for the table data.
+        #
+        # the table data array will contain arrays of String objects, each one
+        # corresponding to a row in the table.
+        table_options = { font: :my_new_david,
+                          header_font: :my_new_david_bold,
+                          max_font_size: 12,
+                          column_widths:  (params['bates']['date_header'].to_s.empty? ? [3, 40, 4] : [3, 10, 30, 4]),
+                          table_data: [] }
+
+        # set the table header array.
+        # this is an array of strings.
+        # to chose the localized strings
+        table_options[:headers] = [params['bates']['number_header'],
+                                   (params['bates']['date_header'].to_s.empty? ? nil : params['bates']['date_header']),
+                                   params['bates']['title_header'].to_s,
+                                   params['bates']['page_header'].to_s]
+        table_options[:headers].compact!
+
+        # by default, there are 25 rows per page for table pdf created by CombinePDF
+        # we can override this in the formatting (but we didn't).
+        #
+        # the 25 rows include 1 header row per page - so there are only 24 effective rows.
+        #
+        # we will calculate how many pages the table of contents pdf will have once completes,
+        # so we can add the count to the page numbers in the index.
+        index_page_length = pdfs_pages_count.length / 24
+        index_page_length += 1 if pdfs_pages_count.length % 24 > 0
+
+        # set the page number for the first entry in the table of contents.
+        page_number = first_page_number + index_page_length
+
+        # set the index count to 0, we will use it to change the index for each entry.
+        # we need a different variable in case the first PDF file is a "cover page".
+        index_count = 0
+
+        # iterate over the data we collected before and add it to the table data.
+        pdfs_pages_count.each_index do |i|
+          # add the data unless it is set to be ignored
+          unless ignore_first_file
+
+            # add an array of strings to the :table_data array,
+            # representing a row in our table.
+            # remember there might not be a date column.
+            if params['bates']['date_header'].to_s.empty?
+              table_options[:table_data] << [(first_index_number + index_count).to_s,
+                                             pdf_titles[i], page_number]
+            else
+              table_options[:table_data] << [(first_index_number + index_count).to_s,
+                                             pdf_dates[i],
+                                             pdf_titles[i], page_number]
+            end
+
+            # if the data was added to the index table, bump the index count
+            index_count += 1
+
+          end
+
+          # make sure future data will not be ignored
+          ignore_first_file = false
+
+          # add the page count to the page number, so that the next
+          # index's page number is up to date.
+          page_number += pdfs_pages_count[i]
+        end
+
+        # if out current locale is hebrew, which is a right to left language,
+        # set the direction for the table to Right-To-left (:rtl).
+        #
+        # notice that RTL text should be automatically recognized, but that
+        # feature isn't available (and shouldn't be available) for tables.
+        table_options[:direction] = :rtl if params['bates']['dir'] == 'rtl'
+
+        # if there is table data, we will create an index pdf.
+        unless table_options[:table_data].empty?
+
+          # create the index PDF from the table data and options we have.
+          index_pdf = CombinePDF.create_table table_options
+
+          # We will now add the words "Table of Contents" (or the I18n equivilant)
+          # to the first page of our new index_pdf PDF object.
+          #
+          # the table PDF object was created by CombinePDF using writable PDF pages,
+          # so we have properties like .mediabox and methods like .textbox
+          # at our disposal.
+
+          # get the first page of the index_pdf object, we will use this reference a lot.
+          title_page = index_pdf.pages[0]
+
+          # write the textbox, using the mediabox page data [x,y,width,height] to place
+          # the text we want to write.
+          #
+          # we will use the I18n.t shortcut to choose the text to write down.
+          title_page.textbox params['bates']['index_title'],
+                             y: ((title_page.mediabox[3] - title_page.mediabox[1]) * 0.91),
+                             height: ((title_page.mediabox[3] - title_page.mediabox[1]) * 0.03),
+                             font: :my_new_david,
+                             max_font_size: 36,
+                             text_valign: :bottom
+
+          # now we will add the index_pdf to the BEGINING of the completed pdf.
+          # for this we will use the >> operator instead of the << operator.
+          completed_pdf >> index_pdf
+
+        end
+
+      end
+
+      # add first file if it was skipped
+      completed_pdf >> first_page unless first_page.nil?
+
+      #####
+      # number pages
+      # unless no numbering
+      if params['bates']['numbering'].to_i != 3
+        # list the numbering options
+        numbering_options = [[:top, :bottom], [:top_left, :bottom_left], [:top_right, :bottom_right]]
+
+        # set the first visible page number to the page where numbering starts
+        # this assumes that the bates numbering include the numbering of the "cover page",
+        # yet at the same time the numbering isn't visible on the "cover page"
+        first_page_number += pdfs_pages_count[0] if params['bates']['first_pdf_is_cover'] && params['bates']['skip_cover']
+
+        # call the page numbering method and
+        # add the special properties we want for the textbox
+        completed_pdf.number_pages(start_at: first_page_number,
+                                   page_range: params['bates']['skip_cover'] ? (pdfs_pages_count[0].to_i..-1) : nil,
+                                   font_name: :my_new_david,
+                                   font_size: 14,
+                                   font_color: [0, 0, 0.4],
+                                   box_color: [0.8, 0.8, 0.8],
+                                   border_width: 1,
+                                   border_color: [0.3, 0.3, 0.3],
+                                   box_radius: 8,
+                                   number_location: numbering_options[params['bates']['numbering'].to_i],
+                                   opacity: 0.75)
+      end
+
+      # send the completed PDF to the client.
+      # if the completed PDF is empty, raise an error.
+      if completed_pdf.pages.empty?
+        # inform the client there was an unknown error.
+        response = STATIC_RESPONSE.dup
+        response[1] = response[1].dup
+        response[1]['set-cookie'] = "Unknown error - 0 pages."
+        return response
+      end
+
+      # make sure the PDF version is high enough for the opacity we used in the page numbering.
+      completed_pdf.version = [completed_pdf.version, 1.6].max
+
+      # we will format the PDF to a pdf file WITHOUT saving it to the file system,
+      # using the .to_pdf method (instead of the .save method).
+      # we will send the raw PDF data stream.
+      return [200, {'content-type' => "application/pdf",
+                    'content-disposition' => "attachment; filename=\"#{output_name}\""}, completed_pdf.to_pdf]
+
+    rescue Exception => e
+      puts e.message, e.backtrace
+      puts "The file causing the exception is: #{file_name}"
+      # if an exception was raised, tell the user which PDF caused the exception
+      response = STATIC_RESPONSE.dup
+      response[1] = response[1].dup
+      response[1]['set-cookie'] = "notice=Unsupported or error reading file: #{file_name}"
+      return response
+    end
+  end
+end
+
+Iodine.workers = 1
+Iodine.threads = 5
+Iodine::DEFAULT_SETTINGS[:public] ||= './public'
+
+p Iodine::DEFAULT_SETTINGS
+Iodine::DEFAULT_SETTINGS[:max_body] = 70 if Iodine::DEFAULT_SETTINGS[:max_body].to_i < 5
+
+run BatesAPP