curb 1.3.6 → 1.4.0

data/ext/curb_multi.h

@@ -21,6 +21,10 @@ typedef struct {
   char allow_close_during_perform;
   CURLM *handle;
   struct st_table *attached;
+  /* Bumped on every add and stamped onto the easy (multi_attachment_generation),
+   * so "attached after point X" is a comparison instead of a table snapshot.
+   * Monotonic for the object's lifetime; never reset. */
+  unsigned long attachment_sequence;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;

data/ext/curb_postfield.c

@@ -468,7 +468,10 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
     name = rbcpf->name;
     if (TYPE(name) != T_STRING) {
       if (rb_respond_to(name, rb_intern("to_s")))
-        name = rb_funcall(name, rb_intern("to_s"), 0);
+        /* rb_obj_as_string always yields a String, even if #to_s misbehaves
+         * and returns a non-String; a raw rb_funcall result could later be
+         * handed to RSTRING_PTR/RSTRING_LEN and crash. */
+        name = rb_obj_as_string(name);
       else
         name = Qnil;
     }
@@ -481,6 +484,33 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
   /* Force field name to UTF-8 before escaping */
   VALUE name_utf8 = rb_str_export_to_enc(name, rb_utf8_encoding());
 
+  /* Resolve and coerce the content before creating the curl handle: the
+   * content proc, #to_s and the UTF-8 export can all raise, which would
+   * otherwise leak the handle. */
+  VALUE tmpcontent = Qnil;
+  if (rbcpf->content_proc != Qnil) {
+    tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+  } else if (rbcpf->content != Qnil) {
+    tmpcontent = rbcpf->content;
+  } else if (rbcpf->local_file != Qnil) {
+    tmpcontent = rbcpf->local_file;
+  } else if (rbcpf->remote_file != Qnil) {
+    tmpcontent = rbcpf->remote_file;
+  } else {
+    tmpcontent = rb_str_new2("");
+  }
+  if (TYPE(tmpcontent) != T_STRING) {
+    if (rb_respond_to(tmpcontent, rb_intern("to_s")))
+      /* rb_obj_as_string always yields a String, even if #to_s misbehaves */
+      tmpcontent = rb_obj_as_string(tmpcontent);
+    else
+      rb_raise(rb_eRuntimeError,
+               "postfield(%"PRIsVALUE") is not a string and does not respond_to to_s",
+               name);
+  }
+  /* Force content to UTF-8 before escaping */
+  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
+
 #ifdef HAVE_CURL_EASY_ESCAPE
   curl_handle = curl_easy_init();
   if (!curl_handle) {
@@ -499,38 +529,8 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
 #endif
 
   VALUE escd_name = rb_str_new2(tmpchrs);
-#ifdef HAVE_CURL_EASY_ESCAPE
-  curl_free(tmpchrs);
-#else
   curl_free(tmpchrs);
-#endif
 
-  VALUE tmpcontent = Qnil;
-  if (rbcpf->content_proc != Qnil) {
-    tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-  } else if (rbcpf->content != Qnil) {
-    tmpcontent = rbcpf->content;
-  } else if (rbcpf->local_file != Qnil) {
-    tmpcontent = rbcpf->local_file;
-  } else if (rbcpf->remote_file != Qnil) {
-    tmpcontent = rbcpf->remote_file;
-  } else {
-    tmpcontent = rb_str_new2("");
-  }
-  if (TYPE(tmpcontent) != T_STRING) {
-    if (rb_respond_to(tmpcontent, rb_intern("to_s")))
-      tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
-    else {
-#ifdef HAVE_CURL_EASY_ESCAPE
-      curl_easy_cleanup(curl_handle);
-#endif
-      rb_raise(rb_eRuntimeError,
-               "postfield(%s) is not a string and does not respond_to to_s",
-               RSTRING_PTR(escd_name));
-    }
-  }
-  /* Force content to UTF-8 before escaping */
-  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
 #ifdef HAVE_CURL_EASY_ESCAPE
   tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
   if (!tmpchrs) {

data/ext/extconf.rb

@@ -260,6 +260,7 @@ have_constant "curl_version_idn"
 have_constant "curl_version_sspi"
 have_constant "curl_version_conv"
 have_constant "curl_version_http2"
+have_constant "curl_version_threadsafe"
 have_constant "curlproxy_http"
 have_constant "curlproxy_socks4"
 have_constant "curlproxy_socks4a"
@@ -462,6 +463,9 @@ have_constant "curlopt_ftp_use_eprt"
 have_constant "curlopt_ftp_use_epsv"
 have_constant "curlopt_ftp_use_pret"
 have_constant "curlopt_ftp_create_missing_dirs"
+have_constant "curlftp_create_dir_none"
+have_constant "curlftp_create_dir"
+have_constant "curlftp_create_dir_retry"
 have_constant "curlopt_ftp_response_timeout"
 have_constant "curlopt_ftp_alternative_to_user"
 have_constant "curlopt_ftp_skip_pasv_ip"
@@ -700,6 +704,8 @@ have_header('ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_current', 'ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_io_wait', 'ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_io_select', 'ruby/fiber/scheduler.h')
+have_func('rb_fiber_scheduler_kernel_sleep', 'ruby/fiber/scheduler.h')
+have_func('rb_ext_ractor_safe')
 have_func('rb_io_stdio_file')
 have_func('curl_multi_wait')
 have_func('curl_multi_socket_action')
@@ -710,6 +716,10 @@ have_func('curl_multi_socket')
 have_func('curl_multi_timer_callback')
 have_constant 'curlmopt_socketfunction'
 have_constant 'curlmopt_timerfunction'
+# Kernel event queues let the socket-action loop wait on one descriptor for
+# every libcurl socket under a fiber scheduler.
+have_header('sys/epoll.h') && have_func('epoll_create1', 'sys/epoll.h')
+have_header('sys/event.h') && have_func('kqueue', ['sys/types.h', 'sys/event.h'])
 have_func('curl_easy_duphandle')
 
 # Optional: enable verbose socket-action debug logging.

data/lib/curl/easy.rb

@@ -3,13 +3,20 @@ require 'curl/download'
 module Curl
   class Easy
     class << self
+      def deferred_multi_close_state
+        Curl.__send__(:ractor_local_state)
+      end
+      private :deferred_multi_close_state
+
       def deferred_multi_close_mutex
-        @deferred_multi_close_mutex ||= Mutex.new
+        state = deferred_multi_close_state
+        state[:deferred_multi_close_mutex] ||= Mutex.new
       end
 
       def deferred_multi_closes
+        state = deferred_multi_close_state
         deferred_multi_close_mutex.synchronize do
-          (@deferred_multi_closes ||= []).dup
+          (state[:deferred_multi_closes] ||= []).dup
         end
       end
 
@@ -34,27 +41,29 @@ module Curl
       end
 
       def defer_multi_close(multi, easy, owner: Thread.current)
+        state = deferred_multi_close_state
         deferred_multi_close_mutex.synchronize do
-          @deferred_multi_closes ||= []
-          return if @deferred_multi_closes.any? { |entry| entry[:multi].equal?(multi) }
+          state[:deferred_multi_closes] ||= []
+          return if state[:deferred_multi_closes].any? { |entry| entry[:multi].equal?(multi) }
 
           multi.instance_variable_set(:@deferred_close, true)
-          @deferred_multi_closes << { multi: multi, easy: easy, owner: owner }
+          state[:deferred_multi_closes] << { multi: multi, easy: easy, owner: owner }
         end
       end
 
       def flush_deferred_multi_closes(all_threads: false)
+        state = deferred_multi_close_state
         pending = deferred_multi_close_mutex.synchronize do
-          @deferred_multi_closes ||= []
+          deferred_closes = (state[:deferred_multi_closes] ||= [])
 
           if all_threads
-            @deferred_multi_closes.shift(@deferred_multi_closes.length)
+            deferred_closes.shift(deferred_closes.length)
           else
             owner = Thread.current
             remaining = []
             current = []
 
-            @deferred_multi_closes.each do |entry|
+            deferred_closes.each do |entry|
               if entry[:owner].equal?(owner)
                 current << entry
               else
@@ -62,7 +71,7 @@ module Curl
               end
             end
 
-            @deferred_multi_closes = remaining
+            state[:deferred_multi_closes] = remaining
             current
           end
         end

data/lib/curl.rb

@@ -8,6 +8,19 @@ require 'uri'
 
 # expose shortcut methods
 module Curl
+  # Module/class instance variables cannot be read or written by non-main
+  # Ractors, even when the value itself would otherwise be safe. Keep curb's
+  # mutable Ruby-side configuration in storage owned by the current Ractor.
+  # Older Rubies retain the historical process-wide state.
+  def self.ractor_local_state
+    if defined?(Ractor) && Ractor.respond_to?(:current) &&
+       Ractor.current.respond_to?(:[]) && Ractor.current.respond_to?(:[]=)
+      Ractor.current[:__curb_ractor_local_state] ||= {}
+    else
+      @legacy_local_state ||= {}
+    end
+  end
+
   class SafetyConfig
     DEFAULT_PROTOCOLS = [:http, :https].freeze
 
@@ -176,12 +189,12 @@ module Curl
   def self.safe!
     config = SafetyConfig.new
     yield config if block_given?
-    @safety_config = config
+    ractor_local_state[:safety_config] = config
     bump_safety_generation!
   end
 
   def self.apply_safety!(easy)
-    config = @safety_config
+    config = ractor_local_state[:safety_config]
     override = safety_override_for(easy)
     return easy unless config || override
 
@@ -215,12 +228,12 @@ module Curl
   end
 
   def self.clear_safe!
-    @safety_config = nil
+    ractor_local_state[:safety_config] = nil
     bump_safety_generation!
   end
 
   def self.safety_active_for?(easy)
-    !!(@safety_config || safety_override_for(easy))
+    !!(ractor_local_state[:safety_config] || safety_override_for(easy))
   end
 
   def self.safety_signature_for(easy)
@@ -240,11 +253,11 @@ module Curl
   end
 
   def self.safety_generation
-    @safety_generation ||= 0
+    ractor_local_state[:safety_generation] ||= 0
   end
 
   def self.bump_safety_generation!
-    @safety_generation = safety_generation + 1
+    ractor_local_state[:safety_generation] = safety_generation + 1
   end
 
   def self.safety_protocol_intersection(base_protocols, override_protocols)
@@ -395,7 +408,8 @@ module Curl
     easy.set(Curl::CURLOPT_NOPROXY, "*") if Curl.const_defined?(:CURLOPT_NOPROXY)
   end
 
-  private_class_method :apply_safety!, :clear_safe!, :safety_active_for?,
+  private_class_method :ractor_local_state,
+                       :apply_safety!, :clear_safe!, :safety_active_for?,
                        :safety_signature_for, :safety_override_for,
                        :safety_generation, :bump_safety_generation!,
                        :safety_protocol_intersection,
@@ -480,23 +494,44 @@ module Curl
     end
   end
 
+  # Wakes the waiters whose transfers finished since the last call. Completions
+  # are queued by the on_complete wrapper in perform_with_scheduler, so each
+  # drive-loop pass costs O(new completions) rather than O(all waiters).
   def self.release_scheduler_waiters(state)
-    source_id = deferred_exception_source_id(state)
+    completed = state[:completed]
+    return if completed.empty?
 
-    state[:waiters].each do |easy_id, waiter|
-      next if source_id == easy_id
+    source_id = deferred_exception_source_id(state)
+    retained = nil
+
+    until completed.empty?
+      easy_id, waiter = completed.shift
+      # A waiter whose perform already returned (it raised) is no longer
+      # blocked on this completion; waking its fiber would be spurious.
+      next unless state[:waiters][easy_id].equal?(waiter)
+
+      if source_id == easy_id
+        # The transfer that raised the deferred exception gets that error via
+        # release_scheduler_error. Keep it queued in case the source changes.
+        (retained ||= []) << [easy_id, waiter]
+        next
+      end
 
-      complete_scheduler_waiter(waiter) if waiter[:completed]
+      complete_scheduler_waiter(waiter)
     end
+
+    completed.concat(retained) if retained
   end
 
   def self.perform_with_scheduler(easy)
     state = scheduler_state
+    easy_id = easy.object_id
     waiter = {completed: false, done: false, error: nil, fiber: nil, scheduler: Fiber.scheduler}
-    state[:waiters][easy.object_id] = waiter
+    state[:waiters][easy_id] = waiter
     previous_complete = easy.on_complete do |completed_easy|
       previous_complete.call(completed_easy) if previous_complete
       waiter[:completed] = true
+      state[:completed] << [easy_id, waiter]
     end
 
     state[:pending] << easy
@@ -533,6 +568,8 @@ module Curl
         driver_running: false,
         error: nil,
         waiters: {},
+        # [easy object_id, waiter] pairs completed but not yet woken
+        completed: [],
       }
       Thread.current.thread_variable_set(:curb_scheduler_state, state)
       state

data/tests/helper.rb

@@ -228,16 +228,100 @@ module BugTestServerSetupTeardown
     @thread = Thread.new(@server) do|srv|
       srv.start
     end
+
+    # WEBrick#shutdown is a no-op until start has created its shutdown pipe
+    # and set :Running, so wait for that before the test (and its teardown)
+    # runs. Otherwise a teardown racing server startup could miss the brief
+    # :Shutdown status and spin forever once the server settled back on :Stop.
+    sleep 0.001 until @server.status == :Running || !@thread.alive?
+    @thread.value unless @thread.alive?
   end
 
   def teardown
-    while @server.status != :Shutdown
-      @server.shutdown
-    end
+    @server.shutdown
     @thread.join
   end
 end
 
+# Test::Unit creates a new test instance for every test method. Keep the
+# common WEBrick fixture process-scoped so those instances can share it while
+# still allowing an explicit stop_test_server call to exercise lifecycle code.
+module CurbTestServerRegistry
+  Entry = Struct.new(:key, :port, :server, :thread, :lock_file, :pid)
+
+  @mutex = Mutex.new
+  @entries = {}
+
+  class << self
+    def acquire(port, servlet)
+      key = [port, servlet]
+
+      @mutex.synchronize do
+        entry = @entries[key]
+        return entry if active?(entry)
+
+        @entries.delete(key)
+        entry = yield
+        @entries[key] = entry if entry
+        entry
+      end
+    end
+
+    def stop(entry, timeout)
+      return false unless remove(entry)
+
+      shutdown_entry(entry, timeout)
+      true
+    end
+
+    def register_shutdown_hook(entry)
+      # Test::Unit can run a directly executed test file from its own at_exit
+      # callback. Register after startup so this hook runs after that callback.
+      at_exit { stop(entry, 5) }
+    end
+
+    private
+
+    def active?(entry)
+      entry && entry.server && entry.thread && entry.thread.alive? && entry.server.status == :Running
+    rescue StandardError
+      false
+    end
+
+    def remove(entry)
+      @mutex.synchronize do
+        return false unless @entries[entry.key].equal?(entry)
+
+        @entries.delete(entry.key)
+        true
+      end
+    end
+
+    def shutdown_entry(entry, timeout)
+      return unless Process.pid == entry.pid
+
+      begin
+        entry.server.shutdown if entry.server
+      rescue StandardError
+        nil
+      end
+
+      thread = entry.thread
+      if thread
+        thread.join(timeout)
+        if thread.alive?
+          thread.kill
+          thread.join(timeout)
+        end
+      end
+
+      File.unlink(entry.lock_file) if entry.lock_file && File.exist?(entry.lock_file)
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end
+
 module TestServerMethods
   def server_responding?(port)
     socket = TCPSocket.new('127.0.0.1', port)
@@ -267,6 +351,22 @@ module TestServerMethods
     end
   end
 
+  # Waiting on WEBrick's state avoids opening a probe connection for every
+  # startup. On Windows those short-lived connections make server teardown
+  # disproportionately expensive.
+  def wait_for_server_started(server, port, thread: nil)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + server_startup_timeout
+
+    loop do
+      return true if server.status == :Running
+      return false if thread && !thread.alive?
+
+      raise "Failed to startup test server on port #{port}" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      sleep 0.01
+    end
+  end
+
   def server_shutdown_timeout
     [server_startup_timeout, 0.25].max
   end
@@ -337,6 +437,13 @@ module TestServerMethods
   end
 
   def stop_test_server
+    shared_entry = instance_variable_defined?(:@__shared_test_server_entry) ? @__shared_test_server_entry : nil
+    if shared_entry
+      CurbTestServerRegistry.stop(shared_entry, server_shutdown_timeout)
+      release_shared_test_server
+      return
+    end
+
     server = instance_variable_defined?(:@server) ? @server : nil
     pid = instance_variable_defined?(:@__pid) ? @__pid : nil
     return unless server || pid
@@ -382,11 +489,28 @@ module TestServerMethods
   def teardown
     super
   ensure
-    stop_test_server
+    if instance_variable_defined?(:@__shared_test_server_entry) && @__shared_test_server_entry
+      release_shared_test_server
+    else
+      stop_test_server
+    end
   end
 
   def server_setup(port=9129,servlet=TestServlet)
     @__port = port
+
+    unless TEST_SINGLE_THREADED
+      entry = CurbTestServerRegistry.acquire(port, servlet) do
+        start_shared_test_server(port, servlet)
+      end
+
+      if entry
+        attach_shared_test_server(entry)
+      end
+
+      return
+    end
+
     @server = nil unless instance_variable_defined?(:@server)
     @__pid = nil unless instance_variable_defined?(:@__pid)
     @test_thread = nil unless instance_variable_defined?(:@test_thread)
@@ -474,6 +598,64 @@ module TestServerMethods
     end
   rescue Errno::EADDRINUSE
   end
+
+  def attach_shared_test_server(entry)
+    @server = entry.server
+    @test_thread = entry.thread
+    @__pid = nil
+    @__shared_test_server_entry = entry
+  end
+
+  def release_shared_test_server
+    @server = nil
+    @test_thread = nil
+    @__pid = nil
+    @__shared_test_server_entry = nil
+  end
+
+  def start_shared_test_server(port, servlet)
+    clear_stale_server_lock(port)
+
+    if File.exist?(locked_file)
+      begin
+        wait_for_server_ready(port)
+        return nil
+      rescue RuntimeError
+        clear_stale_server_lock(port)
+      end
+    end
+
+    write_server_lock
+    server = WEBrick::HTTPServer.new(:Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__)), :Logger => WEBRICK_TEST_LOG, :AccessLog => [])
+
+    server.mount(servlet.path, servlet)
+    server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+
+    thread = Thread.new(server) { |srv| srv.start }
+    unless wait_for_server_started(server, port, thread: thread)
+      server.shutdown
+      thread.join(server_shutdown_timeout)
+      raise "Failed to startup test server on port #{port}"
+    end
+
+    entry = CurbTestServerRegistry::Entry.new([port, servlet], port, server, thread, locked_file, Process.pid)
+    CurbTestServerRegistry.register_shutdown_hook(entry)
+    entry
+  rescue Errno::EADDRINUSE
+    File.unlink(locked_file) if File.exist?(locked_file)
+    return nil if server_responding?(port)
+
+    raise
+  rescue StandardError
+    begin
+      server.shutdown if defined?(server) && server
+      thread.join(server_shutdown_timeout) if defined?(thread) && thread
+    rescue StandardError
+      nil
+    end
+    File.unlink(locked_file) if File.exist?(locked_file)
+    raise
+  end
 end
 
 
@@ -553,3 +735,117 @@ end
 unless URI.methods.include?(:encode_www_form)
   URI.extend(Backports::Ruby18::URIFormEncoding)
 end
+
+# Valgrind slows every request enough that tight wall-clock bounds stop
+# meaning anything; tests use this to relax or skip only those bounds.
+def curb_under_valgrind?
+  ENV['LD_PRELOAD'].to_s.include?('vgpreload')
+end
+
+# Queue#pop(timeout:) needs Ruby 3.2. Older Rubies take the keyword hash as
+# the positional non_block flag and raise ThreadError immediately.
+def curb_pop_within(queue, seconds)
+  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+  loop do
+    begin
+      return queue.pop(true)
+    rescue ThreadError
+      return nil if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+      sleep 0.01
+    end
+  end
+end
+
+# Minimal HTTP/1.1 server so a test controls exactly when and how a response
+# is written. Every request gets its own connection (Connection: close).
+#
+#   /fast                   "fast" immediately
+#   /delay/<seconds>        "delayed" after sleeping
+#   /hang                   "released" once release_hung is called
+#   /stream/<chunks>/<n>    <chunks> writes of <n> bytes (see stream_body)
+#   /truncate               promises 100000 bytes, sends 10, then closes
+#   /reset                  sends part of a body, then aborts with a TCP RST
+class CurbTinyHTTPServer
+  attr_reader :port, :requests
+
+  # Chunk i is filled with one letter so a test can verify reassembly.
+  def self.stream_body(chunks, bytes)
+    (0...chunks).map { |i| (97 + (i % 26)).chr * bytes }.join
+  end
+
+  def initialize
+    @listener = TCPServer.new('127.0.0.1', 0)
+    @port = @listener.addr[1]
+    @requests = Queue.new
+    @release = Queue.new
+    @clients = []
+    @thread = Thread.new { accept_loop }
+  end
+
+  def url(path)
+    "http://127.0.0.1:#{@port}#{path}"
+  end
+
+  # Let pending /hang requests finish.
+  def release_hung(count = 64)
+    count.times { @release << true }
+  end
+
+  def close
+    release_hung
+    @listener.close rescue nil
+    @thread.kill
+    @thread.join(2)
+    @clients.each { |t| t.kill; t.join(1) }
+  end
+
+  private
+
+  def accept_loop
+    loop do
+      sock = @listener.accept
+      @clients << Thread.new(sock) { |s| handle(s) }
+    end
+  rescue IOError, Errno::EBADF
+    nil
+  end
+
+  def handle(sock)
+    request_line = sock.gets.to_s
+    while (line = sock.gets) && line != "\r\n"; end
+    path = request_line.split(' ')[1].to_s
+    @requests << path
+
+    case path
+    when %r{\A/delay/([\d.]+)}
+      sleep Float($1)
+      respond(sock, "delayed")
+    when '/hang'
+      curb_pop_within(@release, 10)
+      respond(sock, "released")
+    when %r{\A/stream/(\d+)/(\d+)}
+      chunks = Integer($1)
+      bytes = Integer($2)
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: #{chunks * bytes}\r\nConnection: close\r\n\r\n")
+      chunks.times do |i|
+        sock.write((97 + (i % 26)).chr * bytes)
+        Thread.pass
+      end
+    when '/truncate'
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: 100000\r\nConnection: close\r\n\r\n0123456789")
+    when '/reset'
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: 100000\r\nConnection: close\r\n\r\n0123456789")
+      sock.setsockopt(Socket::Option.linger(true, 0))
+    else
+      respond(sock, "fast")
+    end
+  rescue IOError, SystemCallError
+    nil
+  ensure
+    sock.close rescue nil
+  end
+
+  def respond(sock, body)
+    sock.write("HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}")
+  end
+end