polyphony 0.82 → 0.84.1

data/test/test_io.rb

@@ -279,6 +279,153 @@ class IOTest < MiniTest::Test
     sleep 0.01
     assert_equal ['foo', 'bar', 'baz'], receiver.buffer
   end
+
+  def test_splice_from
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    spin {
+      len = o2.splice_from(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foobar')
+    result = i2.read
+
+    assert_equal 'foobar', result
+    assert_equal 6, len
+  end
+
+  def test_splice_class_method
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    spin {
+      len = IO.splice(i1, o2, 1000)
+      o2.close
+    }
+
+    o1.write('foobar')
+    result = i2.read
+
+    assert_equal 'foobar', result
+    assert_equal 6, len
+  end
+
+  def test_splice_to_eof_from
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    f = spin {
+      len = o2.splice_to_eof_from(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foo')
+    result = i2.readpartial(1000)
+    assert_equal 'foo', result
+
+    o1.write('bar')
+    result = i2.readpartial(1000)
+    assert_equal 'bar', result
+    o1.close
+    f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      f.await
+    end
+  end
+
+  def test_splice_to_eof_class_method
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    f = spin {
+      len = IO.splice_to_eof(i1, o2, 1000)
+      o2.close
+    }
+
+    o1.write('foo')
+    result = i2.readpartial(1000)
+    assert_equal 'foo', result
+
+    o1.write('bar')
+    result = i2.readpartial(1000)
+    assert_equal 'bar', result
+    o1.close
+    f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      f.await
+    end
+  end
+
+  def test_tee_from
+    skip "tested only on Linux" unless RUBY_PLATFORM =~ /linux/
+    
+    src = Polyphony.pipe
+    dest1 = Polyphony.pipe
+    dest2 = Polyphony.pipe
+
+    len1 = len2 = nil
+
+    spin {
+      len1 = dest1.tee_from(src, 1000)
+      dest1.close
+      len2 = IO.splice(src, dest2, 1000)
+      dest2.close
+    }
+
+    src << 'foobar'
+    src.close
+    result1 = dest1.read
+    result2 = dest2.read
+
+    assert_equal 'foobar', result1
+    assert_equal 6, len1
+
+    assert_equal 'foobar', result2
+    assert_equal 6, len2
+  end
+
+  def test_tee_class_method
+    skip "tested only on Linux" unless RUBY_PLATFORM =~ /linux/
+    
+    src = Polyphony.pipe
+    dest1 = Polyphony.pipe
+    dest2 = Polyphony.pipe
+
+    len1 = len2 = nil
+
+    spin {
+      len1 = IO.tee(src, dest1, 1000)
+      dest1.close
+      len2 = IO.splice(src, dest2, 1000)
+      dest2.close
+    }
+
+    src << 'foobar'
+    src.close
+    result1 = dest1.read
+    result2 = dest2.read
+
+    assert_equal 'foobar', result1
+    assert_equal 6, len1
+
+    assert_equal 'foobar', result2
+    assert_equal 6, len2
+  end
+
+
+
 end
 
 class IOWithRawBufferTest < MiniTest::Test
@@ -503,3 +650,247 @@ class IOClassMethodsTest < MiniTest::Test
     assert_equal ['foo', 'bar'], buf
   end
 end
+
+class IOExtensionsTest < MiniTest::Test
+  def test_deflate
+    i, o = IO.pipe
+    r, w = IO.pipe
+
+    spin {
+      IO.deflate(i, w)
+      w.close
+    }
+
+    o << 'foobar' * 20
+    o.close
+
+    data = r.read
+    msg = Zlib::Inflate.inflate(data)
+    assert_equal 'foobar' * 20, msg
+  end
+
+  def test_inflate
+    i, o = IO.pipe
+    r, w = IO.pipe
+
+    spin {
+      data = Zlib::Deflate.deflate('foobar', 9)
+      o << data
+      o.close
+    }
+
+    IO.inflate(i, w)
+    w.close
+    msg = r.read
+    assert_equal 'foobar', msg
+  end
+
+  def test_gzip
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+    now = nil
+
+    spin {
+      now = Time.now
+      IO.gzip(src, dest)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_in_range (now-2)..(now+1), gz.mtime
+    assert_nil gz.orig_name
+    assert_nil gz.comment
+  end
+
+  def test_gzip_with_mtime_int
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gzip(src, dest, mtime: 42)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal Time.at(42), gz.mtime
+  end
+
+  def test_gzip_with_mtime_false
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gzip(src, dest, mtime: false)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal Time.at(0), gz.mtime
+  end
+
+  def test_gzip_with_mtime_time
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+    t = Time.at(Time.now.to_i) - rand(300000)
+
+    spin {
+      IO.gzip(src, dest, mtime: t)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal t, gz.mtime
+  end
+
+  def test_gzip_with_orig_name
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gzip(src, dest, orig_name: '/foo/bar')
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal '/foo/bar', gz.orig_name
+  end
+
+  def test_gzip_with_comment
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gzip(src, dest, comment: 'hello!')
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal 'hello!', gz.comment
+  end
+
+  def test_gunzip
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gunzip(src, dest)
+      dest.close
+    }
+
+    gz = Zlib::GzipWriter.new(src, 9)
+    gz << 'foobar'#IO.read(__FILE__)
+    gz.close
+
+    data = dest.read
+    # assert_equal IO.read(__FILE__), data
+    assert_equal 'foobar', data
+  end
+
+  def test_gunzip_multi
+    src1 = Polyphony.pipe
+    src2 = Polyphony.pipe
+    dest = Polyphony.pipe
+
+    spin {
+      IO.gunzip(src1, dest)
+      IO.gunzip(src2, dest)
+      dest.close
+    }
+
+    gz1 = Zlib::GzipWriter.new(src1)
+    gz1 << 'foobar'
+    gz1.close
+
+    gz1 = Zlib::GzipWriter.new(src2)
+    gz1 << 'raboof'
+    gz1.close
+
+    data = dest.read
+    assert_equal 'foobarraboof', data
+  end
+
+  def test_gzip_gunzip
+    gzipped = Polyphony.pipe
+    gunzipped = Polyphony.pipe
+
+    spin { File.open(__FILE__, 'r') { |f| IO.gzip(f, gzipped) }; gzipped.close }
+    spin { IO.gunzip(gzipped, gunzipped); gunzipped.close }
+
+    data = gunzipped.read
+    assert_equal IO.read(__FILE__), data
+  end
+
+  def test_gunzip_with_empty_info
+    gzipped = Polyphony.pipe
+    gunzipped = Polyphony.pipe
+    info = {}
+
+    spin {
+      File.open(__FILE__, 'r') { |f| IO.gzip(f, gzipped, mtime: false) }
+      gzipped.close
+    }
+    spin { IO.gunzip(gzipped, gunzipped, info); gunzipped.close }
+
+    data = gunzipped.read
+    assert_equal IO.read(__FILE__), data
+    assert_equal Time.at(0), info[:mtime]
+    assert_nil info[:orig_name]
+    assert_nil info[:comment]
+  end
+
+  def test_gunzip_with_info
+    src = Polyphony.pipe
+    gzipped = Polyphony.pipe
+    gunzipped = Polyphony.pipe
+
+    src_info = {
+      mtime: 42,
+      orig_name: 'foo.bar',
+      comment: 'hello!'
+    }
+
+    dest_info = {}
+
+    spin { IO.gzip(src, gzipped, src_info); gzipped.close }
+    spin { IO.gunzip(gzipped, gunzipped, dest_info); gunzipped.close }
+
+    src << 'foobar'
+    src.close
+
+    data = gunzipped.read
+    assert_equal 'foobar', data
+    assert_equal Time.at(42), dest_info[:mtime]
+    assert_equal 'foo.bar', dest_info[:orig_name]
+    assert_equal 'hello!', dest_info[:comment]
+  end
+end

data/test/test_pipe.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class PipeTest < MiniTest::Test
+  def test_pipe_creation
+    pipe = Polyphony::Pipe.new
+
+    fds = pipe.fds
+    assert_equal 2, fds.size
+    assert_kind_of Integer, fds[0]
+    assert_kind_of Integer, fds[1]
+    assert_equal false, pipe.closed?
+  end
+
+  def test_polyphony_pipe_method
+    pipe = Polyphony.pipe
+
+    fds = pipe.fds
+    assert_equal 2, fds.size
+    assert_kind_of Integer, fds[0]
+    assert_kind_of Integer, fds[1]
+    assert_equal false, pipe.closed?
+  end
+
+  def test_pipe_splice
+    src = Polyphony::Pipe.new
+    dest = Polyphony::Pipe.new
+
+    spin {
+      IO.splice(src, dest, 8192)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+
+    data = dest.read
+    assert_equal IO.read(__FILE__), data
+  end
+end

data/test/test_process_supervision.rb

@@ -65,7 +65,7 @@ class ProcessSupervisionTest < MiniTest::Test
 
     supervisor = spin { supervise(watcher) }
 
-    sleep 0.1
+    sleep 0.2
     supervisor.terminate
     supervisor.await
 

data/test/test_socket.rb

@@ -208,6 +208,7 @@ class SocketWithRawBufferTest < MiniTest::Test
     port, server = start_tcp_server_on_random_port
     connector = spin { @o = TCPSocket.new('127.0.0.1', port) }
     @i = server.accept
+    connector.await
   end
 
   def test_send_with_raw_buffer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.82'
+  version: 0.84.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-04 00:00:00.000000000 Z
+date: 2022-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -315,16 +315,6 @@ files:
 - ext/libev/ev_win32.c
 - ext/libev/ev_wrap.h
 - ext/libev/test_libev_win32.c
-- ext/liburing/liburing.h
-- ext/liburing/liburing/README.md
-- ext/liburing/liburing/barrier.h
-- ext/liburing/liburing/compat.h
-- ext/liburing/liburing/io_uring.h
-- ext/liburing/queue.c
-- ext/liburing/register.c
-- ext/liburing/setup.c
-- ext/liburing/syscall.c
-- ext/liburing/syscall.h
 - ext/polyphony/backend_common.c
 - ext/polyphony/backend_common.h
 - ext/polyphony/backend_io_uring.c
@@ -334,9 +324,10 @@ files:
 - ext/polyphony/event.c
 - ext/polyphony/extconf.rb
 - ext/polyphony/fiber.c
+- ext/polyphony/io_extensions.c
 - ext/polyphony/libev.c
 - ext/polyphony/libev.h
-- ext/polyphony/liburing.c
+- ext/polyphony/pipe.c
 - ext/polyphony/playground.c
 - ext/polyphony/polyphony.c
 - ext/polyphony/polyphony.h
@@ -350,6 +341,7 @@ files:
 - ext/polyphony/runqueue_ring_buffer.h
 - ext/polyphony/socket_extensions.c
 - ext/polyphony/thread.c
+- ext/polyphony/zlib_conf.rb
 - ext/test_eintr.c
 - lib/polyphony.rb
 - lib/polyphony/adapters/fs.rb
@@ -376,6 +368,7 @@ files:
 - lib/polyphony/extensions/kernel.rb
 - lib/polyphony/extensions/object.rb
 - lib/polyphony/extensions/openssl.rb
+- lib/polyphony/extensions/pipe.rb
 - lib/polyphony/extensions/process.rb
 - lib/polyphony/extensions/socket.rb
 - lib/polyphony/extensions/thread.rb
@@ -397,6 +390,7 @@ files:
 - test/test_global_api.rb
 - test/test_io.rb
 - test/test_kernel.rb
+- test/test_pipe.rb
 - test/test_process_supervision.rb
 - test/test_queue.rb
 - test/test_raw_buffer.rb

data/ext/liburing/liburing/README.md

@@ -1,4 +0,0 @@
-## Updating the liburing source code
-
-- copy liburing/src/**/* into ext/liburing
-- move ext/liburing/include/**/* to ext/liburing/

data/ext/liburing/liburing/barrier.h

@@ -1,73 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-#ifndef LIBURING_BARRIER_H
-#define LIBURING_BARRIER_H
-
-/*
-From the kernel documentation file refcount-vs-atomic.rst:
-
-A RELEASE memory ordering guarantees that all prior loads and
-stores (all po-earlier instructions) on the same CPU are completed
-before the operation. It also guarantees that all po-earlier
-stores on the same CPU and all propagated stores from other CPUs
-must propagate to all other CPUs before the release operation
-(A-cumulative property). This is implemented using
-:c:func:`smp_store_release`.
-
-An ACQUIRE memory ordering guarantees that all post loads and
-stores (all po-later instructions) on the same CPU are
-completed after the acquire operation. It also guarantees that all
-po-later stores on the same CPU must propagate to all other CPUs
-after the acquire operation executes. This is implemented using
-:c:func:`smp_acquire__after_ctrl_dep`.
-*/
-
-#ifdef __cplusplus
-#include <atomic>
-
-template <typename T>
-static inline void IO_URING_WRITE_ONCE(T &var, T val)
-{
-	std::atomic_store_explicit(reinterpret_cast<std::atomic<T> *>(&var),
-				   val, std::memory_order_relaxed);
-}
-template <typename T>
-static inline T IO_URING_READ_ONCE(const T &var)
-{
-	return std::atomic_load_explicit(
-		reinterpret_cast<const std::atomic<T> *>(&var),
-		std::memory_order_relaxed);
-}
-
-template <typename T>
-static inline void io_uring_smp_store_release(T *p, T v)
-{
-	std::atomic_store_explicit(reinterpret_cast<std::atomic<T> *>(p), v,
-				   std::memory_order_release);
-}
-
-template <typename T>
-static inline T io_uring_smp_load_acquire(const T *p)
-{
-	return std::atomic_load_explicit(
-		reinterpret_cast<const std::atomic<T> *>(p),
-		std::memory_order_acquire);
-}
-#else
-#include <stdatomic.h>
-
-#define IO_URING_WRITE_ONCE(var, val)				\
-	atomic_store_explicit((_Atomic typeof(var) *)&(var),	\
-			      (val), memory_order_relaxed)
-#define IO_URING_READ_ONCE(var)					\
-	atomic_load_explicit((_Atomic typeof(var) *)&(var),	\
-			     memory_order_relaxed)
-
-#define io_uring_smp_store_release(p, v)			\
-	atomic_store_explicit((_Atomic typeof(*(p)) *)(p), (v), \
-			      memory_order_release)
-#define io_uring_smp_load_acquire(p)				\
-	atomic_load_explicit((_Atomic typeof(*(p)) *)(p),	\
-			     memory_order_acquire)
-#endif
-
-#endif /* defined(LIBURING_BARRIER_H) */

data/ext/liburing/liburing/compat.h

@@ -1,15 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-#ifndef LIBURING_COMPAT_H
-#define LIBURING_COMPAT_H
-
-#include <linux/time_types.h>
-
-#include <inttypes.h>
-
-struct open_how {
-	uint64_t	flags;
-	uint64_t	mode;
-	uint64_t	resolve;
-};
-
-#endif