Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package perl-Future-IO for openSUSE:Factory checked in at 2025-08-27 21:34:21 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/perl-Future-IO (Old) and /work/SRC/openSUSE:Factory/.perl-Future-IO.new.30751 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-Future-IO" Wed Aug 27 21:34:21 2025 rev:8 rq:1301452 version:0.170.0 Changes: -------- --- /work/SRC/openSUSE:Factory/perl-Future-IO/perl-Future-IO.changes 2025-01-07 20:53:06.156126403 +0100 +++ /work/SRC/openSUSE:Factory/.perl-Future-IO.new.30751/perl-Future-IO.changes 2025-08-27 21:35:14.972111028 +0200 @@ -1,0 +2,13 @@ +Fri Aug 22 21:34:07 UTC 2025 - Tina Müller <timueller+p...@suse.de> + +- updated to 0.170.0 (0.17) + see /usr/share/doc/packages/perl-Future-IO/Changes + + 0.17 2025-07-15 + [CHANGES] + * Added new `->send`, `->recv` and `->recvfrom` socket IO wrapping + methods + * Provide `->read` and `->write` as better names for what were named + `->sysread` and `->syswrite` + +------------------------------------------------------------------- Old: ---- Future-IO-0.16.tar.gz New: ---- Future-IO-0.17.tar.gz README.md _scmsync.obsinfo build.specials.obscpio ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ perl-Future-IO.spec ++++++ --- /var/tmp/diff_new_pack.cbW4EY/_old 2025-08-27 21:35:15.536134576 +0200 +++ /var/tmp/diff_new_pack.cbW4EY/_new 2025-08-27 21:35:15.540134742 +0200 @@ -1,7 +1,7 @@ # # spec file for package perl-Future-IO # -# Copyright (c) 2024 SUSE LLC +# Copyright (c) 2025 SUSE LLC and contributors # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,24 +18,25 @@ %define cpan_name Future-IO Name: perl-Future-IO -Version: 0.160.0 +Version: 0.170.0 Release: 0 -# 0.16 -> normalize -> 0.160.0 -%define cpan_version 0.16 +# 0.17 -> normalize -> 0.170.0 +%define cpan_version 0.17 License: Artistic-1.0 OR GPL-1.0-or-later Summary: Future-returning IO methods URL: https://metacpan.org/release/%{cpan_name} Source0: https://cpan.metacpan.org/authors/id/P/PE/PEVANS/%{cpan_name}-%{cpan_version}.tar.gz Source1: cpanspec.yml +Source100: README.md BuildArch: noarch BuildRequires: perl BuildRequires: perl-macros BuildRequires: perl(Future) -BuildRequires: perl(Module::Build) >= 0.4004 +BuildRequires: perl(Module::Build) >= 0.400.400 BuildRequires: perl(Struct::Dumb) BuildRequires: perl(Test2::V0) -BuildRequires: perl(Test::ExpectAndCheck) >= 0.60.0 -BuildRequires: perl(Test::Future::IO::Impl) +BuildRequires: perl(Test::ExpectAndCheck) >= 0.60 +BuildRequires: perl(Test::Future::IO::Impl) >= 0.150 Requires: perl(Future) Requires: perl(Struct::Dumb) Provides: perl(Future::IO) = %{version} @@ -55,7 +56,7 @@ implementation of these operations. %prep -%autosetup -n %{cpan_name}-%{cpan_version} +%autosetup -n %{cpan_name}-%{cpan_version} -p1 %build perl Build.PL --installdirs=vendor ++++++ Future-IO-0.16.tar.gz -> Future-IO-0.17.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/Build.PL new/Future-IO-0.17/Build.PL --- old/Future-IO-0.16/Build.PL 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/Build.PL 2025-07-15 21:45:32.000000000 +0200 @@ -15,7 +15,7 @@ }, test_requires => { 'Test::ExpectAndCheck' => '0.06', - 'Test::Future::IO::Impl' => 0, + 'Test::Future::IO::Impl' => '0.15', 'Test2::V0' => 0, }, configure_requires => { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/Changes new/Future-IO-0.17/Changes --- old/Future-IO-0.16/Changes 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/Changes 2025-07-15 21:45:32.000000000 +0200 @@ -1,5 +1,12 @@ Revision history for Future-IO +0.17 2025-07-15 + [CHANGES] + * Added new `->send`, `->recv` and `->recvfrom` socket IO wrapping + methods + * Provide `->read` and `->write` as better names for what were named + `->sysread` and `->syswrite` + 0.16 2024-09-16 [CHANGES] * Added `Future::IO->load_impl` convenience method for toplevel diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/LICENSE new/Future-IO-0.17/LICENSE --- old/Future-IO-0.16/LICENSE 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/LICENSE 2025-07-15 21:45:32.000000000 +0200 @@ -1,4 +1,4 @@ -This software is copyright (c) 2024 by Paul Evans <leon...@leonerd.org.uk>. +This software is copyright (c) 2025 by Paul Evans <leon...@leonerd.org.uk>. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. @@ -12,7 +12,7 @@ --- The GNU General Public License, Version 1, February 1989 --- -This software is Copyright (c) 2024 by Paul Evans <leon...@leonerd.org.uk>. +This software is Copyright (c) 2025 by Paul Evans <leon...@leonerd.org.uk>. This is free software, licensed under: @@ -272,7 +272,7 @@ --- The Perl Artistic License 1.0 --- -This software is Copyright (c) 2024 by Paul Evans <leon...@leonerd.org.uk>. +This software is Copyright (c) 2025 by Paul Evans <leon...@leonerd.org.uk>. This is free software, licensed under: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/MANIFEST new/Future-IO-0.17/MANIFEST --- old/Future-IO-0.16/MANIFEST 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/MANIFEST 2025-07-15 21:45:32.000000000 +0200 @@ -11,14 +11,16 @@ README t/00use.t t/01sleep.t -t/02sysread.t -t/03sysread_exactly.t -t/03sysread_until_eof.t -t/04syswrite.t -t/05syswrite_exactly.t +t/02read.t +t/03read_exactly.t +t/03read_until_eof.t +t/04write.t +t/05write_exactly.t t/06connect.t t/07accept.t -t/10sleep+sysread.t +t/08send.t +t/09recv.t +t/10sleep+read.t t/20impl-override.t t/21impl-before-load.t t/30system.t diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/META.json new/Future-IO-0.17/META.json --- old/Future-IO-0.16/META.json 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/META.json 2025-07-15 21:45:32.000000000 +0200 @@ -31,22 +31,22 @@ "requires" : { "Test2::V0" : "0", "Test::ExpectAndCheck" : "0.06", - "Test::Future::IO::Impl" : "0" + "Test::Future::IO::Impl" : "0.15" } } }, "provides" : { "Future::IO" : { "file" : "lib/Future/IO.pm", - "version" : "0.16" + "version" : "0.17" }, "Future::IO::ImplBase" : { "file" : "lib/Future/IO/ImplBase.pm", - "version" : "0.16" + "version" : "0.17" }, "Future::IO::System" : { "file" : "lib/Future/IO/System.pm", - "version" : "0.16" + "version" : "0.17" } }, "release_status" : "stable", @@ -55,6 +55,6 @@ "http://dev.perl.org/licenses/"; ] }, - "version" : "0.16", + "version" : "0.17", "x_serialization_backend" : "JSON::PP version 4.16" } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/META.yml new/Future-IO-0.17/META.yml --- old/Future-IO-0.16/META.yml 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/META.yml 2025-07-15 21:45:32.000000000 +0200 @@ -5,7 +5,7 @@ build_requires: Test2::V0: '0' Test::ExpectAndCheck: '0.06' - Test::Future::IO::Impl: '0' + Test::Future::IO::Impl: '0.15' configure_requires: Module::Build: '0.4004' dynamic_config: 1 @@ -18,13 +18,13 @@ provides: Future::IO: file: lib/Future/IO.pm - version: '0.16' + version: '0.17' Future::IO::ImplBase: file: lib/Future/IO/ImplBase.pm - version: '0.16' + version: '0.17' Future::IO::System: file: lib/Future/IO/System.pm - version: '0.16' + version: '0.17' requires: Future: '0' Struct::Dumb: '0' @@ -32,5 +32,5 @@ perl: '5.014' resources: license: http://dev.perl.org/licenses/ -version: '0.16' +version: '0.17' x_serialization_backend: 'CPAN::Meta::YAML version 0.018' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/README new/Future-IO-0.17/README --- old/Future-IO-0.16/README 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/README 2025-07-15 21:45:32.000000000 +0200 @@ -9,7 +9,7 @@ my $delay = Future::IO->sleep( 5 ); # $delay will become done in 5 seconds time - my $input = Future::IO->sysread( \*STDIN, 4096 ); + my $input = Future::IO->read( \*STDIN, 4096 ); # $input will yield some input from the STDIN IO handle DESCRIPTION @@ -27,8 +27,8 @@ If the override_impl method is not invoked, a default implementation of these operations is provided. This implementation allows a single queue - of sysread or syswrite calls on a single filehandle only, combined with - sleep calls. It does not support waitpid. + of read or write calls on a single filehandle only, combined with sleep + calls. It does not support waitpid. It is provided for the simple cases where modules only need one filehandle (most likely a single network socket or hardware device @@ -96,16 +96,12 @@ Returns a Future that will become done when a connect() has succeeded on the given filehandle to the given sockname address. - sleep - - await Future::IO->sleep( $secs ); - - Returns a Future that will become done a fixed delay from now, given in - seconds. This value may be fractional. + read - sysread + $bytes = await Future::IO->read( $fh, $length ); - $bytes = await Future::IO->sysread( $fh, $length ); + Since version 0.17. Before this version this method used to be named + sysread, and still available via that alias. Returns a Future that will become done when at least one byte can be read from the given filehandle. It may return up to $length bytes. On @@ -116,11 +112,12 @@ Note specifically this may perform only a single sysread() call, and thus is not guaranteed to actually return the full length. - sysread_exactly + read_exactly - $bytes = await Future::IO->sysread_exactly( $fh, $length ); + $bytes = await Future::IO->read_exactly( $fh, $length ); - Since version 0.03. + Since version 0.17. Before this version this method used to be named + sysread_exactly, and still available via that alias. Returns a Future that will become done when exactly the given number of bytes have been read from the given filehandle. It returns exactly @@ -132,42 +129,63 @@ This may make more than one sysread() call. - sysread_until_eof + read_until_eof - $f = Future::IO->sysread_until_eof( $fh ); + $f = Future::IO->read_until_eof( $fh ); - Since version 0.12. + Since version 0.17. Before this version this method used to be named + sysread_until_eof, and still available via that alias. Returns a Future that will become done when the given filehandle reaches the EOF condition. The returned future will yield all of the bytes read up until that point. - syswrite + recv - $written_len = await Future::IO->syswrite( $fh, $bytes ); + recvfrom - Since version 0.04. + $bytes = await Future::IO->recv( $fh, $length ); + $bytes = await Future::IO->recv( $fh, $length, $flags ); + + ( $bytes, $from ) = await Future::IO->recvfrom( $fh, $length ); + ( $bytes, $from ) = await Future::IO->recvfrom( $fh, $length, $flags ); - Returns a Future that will become done when at least one byte has been - written to the given filehandle. It may write up to all of the bytes. - On any error (other than EAGAIN / EWOULDBLOCK which are ignored) the - future fails with a suitable error message. + Since version 0.17. - Note specifically this may perform only a single syswrite() call, and - thus is not guaranteed to actually return the full length. + Returns a Future that will become done when at least one byte is + received from the given filehandle (presumably a socket), by using a + recv(2) or recvfrom(2) system call. On any error (other than EAGAIN / + EWOULDBLOCK which are ignored) the future fails with a suitable error + message. - syswrite_exactly + Optionally a flags bitmask in $flags can be passed. If no flags are + required, the value may be zero. The recvfrom method additionally + returns the sender's address as a second result value; this is + primarily used by unconnected datagram sockets. + + send + + $sent_lem = await Future::IO->send( $fh, $bytes ); + $sent_lem = await Future::IO->send( $fh, $bytes, $flags ); + $sent_lem = await Future::IO->send( $fh, $bytes, $flags, $to ); - $written_len = await Future::IO->syswrite_exactly( $fh, $bytes ); + Since version 0.17. - Since version 0.04. + Returns a Future that will become done when at least one byte has been + sent to the given filehandle (presumably a socket), by using a send(2) + system call. On any error (other than EAGAIN / EWOULDBLOCK which are + ignored) the future fails with a suitable error message. + + Optionally a flags bitmask in $flags or a destination address in $to + can also be passed. If no flags are required, the value may be zero. If + $to is specified then a sendto(2) system call is used instead. - Returns a Future that will become done when exactly the given bytes - have been written to the given filehandle. On any error (other than - EAGAIN / EWOULDBLOCK which are ignored) the future fails with a - suitable error message. + sleep - This may make more than one syswrite() call. + await Future::IO->sleep( $secs ); + + Returns a Future that will become done a fixed delay from now, given in + seconds. This value may be fractional. waitpid @@ -187,6 +205,35 @@ say "Terminated with exit code $exitcode"; } + write + + $written_len = await Future::IO->write( $fh, $bytes ); + + Since version 0.17. Before this version this method used to be named + syswrite, and still available via that alias. + + Returns a Future that will become done when at least one byte has been + written to the given filehandle. It may write up to all of the bytes. + On any error (other than EAGAIN / EWOULDBLOCK which are ignored) the + future fails with a suitable error message. + + Note specifically this may perform only a single syswrite() call, and + thus is not guaranteed to actually return the full length. + + write_exactly + + $written_len = await Future::IO->write_exactly( $fh, $bytes ); + + Since version 0.17. Before this version this method used to be named + syswrite_exactly, and still available via that alias. + + Returns a Future that will become done when exactly the given bytes + have been written to the given filehandle. On any error (other than + EAGAIN / EWOULDBLOCK which are ignored) the future fails with a + suitable error message. + + This may make more than one syswrite() call. + override_impl Future::IO->override_impl( $impl ); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/lib/Future/IO/ImplBase.pm new/Future-IO-0.17/lib/Future/IO/ImplBase.pm --- old/Future-IO-0.16/lib/Future/IO/ImplBase.pm 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/lib/Future/IO/ImplBase.pm 2025-07-15 21:45:32.000000000 +0200 @@ -1,9 +1,9 @@ # You may distribute under the terms of either the GNU General Public License # or the Artistic License (the same terms as Perl itself) # -# (C) Paul Evans, 2019-2021 -- leon...@leonerd.org.uk +# (C) Paul Evans, 2019-2025 -- leon...@leonerd.org.uk -package Future::IO::ImplBase 0.16; +package Future::IO::ImplBase 0.17; use v5.14; use warnings; @@ -132,6 +132,94 @@ } ); } +=head2 recv + +=head2 recvfrom + +Implemented by wrapping C<ready_for_read>, as L</sysread> uses. + +=cut + +sub _recv1 +{ + my $self = shift; + my ( $f, $with_fromaddr, $fh, $length, $flags ) = @_; + + my $waitf = $self->ready_for_read( $fh )->on_done( sub { + my $fromaddr = $fh->recv( my $buf, $length, $flags ); + if( defined $fromaddr and length $buf ) { + $f->done( $buf, $with_fromaddr ? ( $fromaddr ) : () ); + } + elsif( defined $fromaddr ) { + $f->done(); # fromaddr is not interesting at EOF + } + elsif( $! == EAGAIN or $! == EWOULDBLOCK ) { + # Try again + $self->_recv1( $f, $with_fromaddr, $fh, $length, $flags ); + } + else { + my $name = $with_fromaddr ? "recvfrom" : "recv"; + $f->fail( "$name: $!\n", $name => $fh, $! ); + } + }); + + $f //= $waitf->new; + + $f->on_cancel( $waitf ); + + return $f; +} + +sub recv +{ + my $self = shift; + return $self->_recv1( undef, 0, @_ ); +} + +sub recvfrom +{ + my $self = shift; + return $self->_recv1( undef, 1, @_ ); +} + +=head2 send + +Implemented by wrapping C<ready_for_write>, as L</syswrite> uses. + +=cut + +sub _send1 +{ + my $self = shift; + my ( $f, $fh, $data, $flags, $to ) = @_; + + my $waitf = $self->ready_for_write( $fh )->on_done( sub { + my $len = $fh->send( $data, $flags, $to ); + if( defined $len ) { + $f->done( $len ); + } + elsif( $! == EAGAIN or $! == EWOULDBLOCK ) { + # Try again + $self->_syswrite1( $f, $fh, $data, $flags, $to ); + } + else { + $f->fail( "send: $!\n", send => $fh, $! ); + } + } ); + + $f //= $waitf->new; + + $f->on_cancel( $waitf ); + + return $f; +} + +sub send +{ + my $self = shift; + return $self->_send1( undef, @_ ); +} + =head2 sysread Requires a lower-level method diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/lib/Future/IO/System.pm new/Future-IO-0.17/lib/Future/IO/System.pm --- old/Future-IO-0.16/lib/Future/IO/System.pm 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/lib/Future/IO/System.pm 2025-07-15 21:45:32.000000000 +0200 @@ -3,7 +3,7 @@ # # (C) Paul Evans, 2023 -- leon...@leonerd.org.uk -package Future::IO::System 0.16; +package Future::IO::System 0.17; use v5.14; use warnings; @@ -147,12 +147,12 @@ if( $want_out ) { close $outfh[1]; - push @f, Future::IO->sysread_until_eof( $outfh[0] ); + push @f, Future::IO->read_until_eof( $outfh[0] ); } if( $want_err ) { close $errfh[1]; - push @f, Future::IO->sysread_until_eof( $errfh[0] ); + push @f, Future::IO->read_until_eof( $errfh[0] ); } return Future->needs_all( @f ); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/lib/Future/IO.pm new/Future-IO-0.17/lib/Future/IO.pm --- old/Future-IO-0.16/lib/Future/IO.pm 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/lib/Future/IO.pm 2025-07-15 21:45:32.000000000 +0200 @@ -1,9 +1,9 @@ # You may distribute under the terms of either the GNU General Public License # or the Artistic License (the same terms as Perl itself) # -# (C) Paul Evans, 2019-2023 -- leon...@leonerd.org.uk +# (C) Paul Evans, 2019-2025 -- leon...@leonerd.org.uk -package Future::IO 0.16; +package Future::IO 0.17; use v5.14; use warnings; @@ -33,7 +33,7 @@ my $delay = Future::IO->sleep( 5 ); # $delay will become done in 5 seconds time - my $input = Future::IO->sysread( \*STDIN, 4096 ); + my $input = Future::IO->read( \*STDIN, 4096 ); # $input will yield some input from the STDIN IO handle =head1 DESCRIPTION @@ -51,8 +51,8 @@ If the C<override_impl> method is not invoked, a default implementation of these operations is provided. This implementation allows a single queue of -C<sysread> or C<syswrite> calls on a single filehandle only, combined with -C<sleep> calls. It does not support C<waitpid>. +C<read> or C<write> calls on a single filehandle only, combined with C<sleep> +calls. It does not support C<waitpid>. It is provided for the simple cases where modules only need one filehandle (most likely a single network socket or hardware device handle), allowing such @@ -167,26 +167,12 @@ return ( $IMPL //= "Future::IO::_DefaultImpl" )->connect( $fh, $name ); } -=head2 sleep - - await Future::IO->sleep( $secs ); - -Returns a L<Future> that will become done a fixed delay from now, given in -seconds. This value may be fractional. - -=cut - -sub sleep -{ - shift; - my ( $secs ) = @_; - - return ( $IMPL //= "Future::IO::_DefaultImpl" )->sleep( $secs ); -} +=head2 read -=head2 sysread + $bytes = await Future::IO->read( $fh, $length ); - $bytes = await Future::IO->sysread( $fh, $length ); +I<Since version 0.17.> Before this version this method used to be named +C<sysread>, and still available via that alias. Returns a L<Future> that will become done when at least one byte can be read from the given filehandle. It may return up to C<$length> bytes. On EOF, the @@ -199,7 +185,7 @@ =cut -sub sysread +sub read { shift; my ( $fh, $length ) = @_; @@ -207,11 +193,14 @@ return ( $IMPL //= "Future::IO::_DefaultImpl" )->sysread( $fh, $length ); } -=head2 sysread_exactly +*sysread = \&read; - $bytes = await Future::IO->sysread_exactly( $fh, $length ); +=head2 read_exactly -I<Since version 0.03.> + $bytes = await Future::IO->read_exactly( $fh, $length ); + +I<Since version 0.17.> Before this version this method used to be named +C<sysread_exactly>, and still available via that alias. Returns a L<Future> that will become done when exactly the given number of bytes have been read from the given filehandle. It returns exactly C<$length> @@ -224,7 +213,7 @@ =cut -sub sysread_exactly +sub read_exactly { shift; my ( $fh, $length ) = @_; @@ -235,10 +224,12 @@ return $IMPL->$code( $fh, $length ); } - return _sysread_into_buffer( $IMPL, $fh, $length, \(my $buffer = '') ); + return _read_into_buffer( $IMPL, $fh, $length, \(my $buffer = '') ); } -sub _sysread_into_buffer +*sysread_exactly = \&read_exactly; + +sub _read_into_buffer { my ( $IMPL, $fh, $length, $bufref ) = @_; @@ -249,15 +240,16 @@ $$bufref .= $more; return Future->done( $$bufref ) if length $$bufref >= $length; - return _sysread_into_buffer( $IMPL, $fh, $length, $bufref ); + return _read_into_buffer( $IMPL, $fh, $length, $bufref ); }); } -=head2 sysread_until_eof +=head2 read_until_eof - $f = Future::IO->sysread_until_eof( $fh ); + $f = Future::IO->read_until_eof( $fh ); -I<Since version 0.12.> +I<Since version 0.17.> Before this version this method used to be named +C<sysread_until_eof>, and still available via that alias. Returns a L<Future> that will become done when the given filehandle reaches the EOF condition. The returned future will yield all of the bytes read up @@ -265,17 +257,19 @@ =cut -sub sysread_until_eof +sub read_until_eof { shift; my ( $fh ) = @_; $IMPL //= "Future::IO::_DefaultImpl"; - return _sysread_until_eof( $IMPL, $fh, \(my $buffer = '') ); + return _read_until_eof( $IMPL, $fh, \(my $buffer = '') ); } -sub _sysread_until_eof +*sysread_until_eof = \&read_until_eof; + +sub _read_until_eof { my ( $IMPL, $fh, $bufref ) = @_; @@ -284,74 +278,93 @@ return Future->done( $$bufref ) if !defined $more; $$bufref .= $more; - return _sysread_until_eof( $IMPL, $fh, $bufref ); + return _read_until_eof( $IMPL, $fh, $bufref ); }); } -=head2 syswrite +=head2 recv - $written_len = await Future::IO->syswrite( $fh, $bytes ); +=head2 recvfrom -I<Since version 0.04.> + $bytes = await Future::IO->recv( $fh, $length ); + $bytes = await Future::IO->recv( $fh, $length, $flags ); -Returns a L<Future> that will become done when at least one byte has been -written to the given filehandle. It may write up to all of the bytes. On any -error (other than C<EAGAIN> / C<EWOULDBLOCK> which are ignored) the future -fails with a suitable error message. + ( $bytes, $from ) = await Future::IO->recvfrom( $fh, $length ); + ( $bytes, $from ) = await Future::IO->recvfrom( $fh, $length, $flags ); -Note specifically this may perform only a single C<syswrite()> call, and thus -is not guaranteed to actually return the full length. +I<Since version 0.17.> + +Returns a L<Future> that will become done when at least one byte is received +from the given filehandle (presumably a socket), by using a C<recv(2)> or +C<recvfrom(2)> system call. On any error (other than C<EAGAIN> / +C<EWOULDBLOCK> which are ignored) the future fails with a suitable error +message. + +Optionally a flags bitmask in C<$flags> can be passed. If no flags are +required, the value may be zero. The C<recvfrom> method additionally returns +the sender's address as a second result value; this is primarily used by +unconnected datagram sockets. =cut -sub syswrite +sub recv { shift; - my ( $fh, $bytes ) = @_; + my ( $fh, $length, $flags ) = @_; - return ( $IMPL //= "Future::IO::_DefaultImpl" )->syswrite( $fh, $bytes ); + return ( $IMPL //= "Future::IO::_DefaultImpl" )->recv( $fh, $length, $flags ); } -=head2 syswrite_exactly +sub recvfrom +{ + shift; + my ( $fh, $length, $flags ) = @_; - $written_len = await Future::IO->syswrite_exactly( $fh, $bytes ); + return ( $IMPL //= "Future::IO::_DefaultImpl" )->recvfrom( $fh, $length, $flags ); +} -I<Since version 0.04.> +=head2 send -Returns a L<Future> that will become done when exactly the given bytes have -been written to the given filehandle. On any error (other than C<EAGAIN> / -C<EWOULDBLOCK> which are ignored) the future fails with a suitable error -message. + $sent_lem = await Future::IO->send( $fh, $bytes ); + $sent_lem = await Future::IO->send( $fh, $bytes, $flags ); + $sent_lem = await Future::IO->send( $fh, $bytes, $flags, $to ); -This may make more than one C<syswrite()> call. +I<Since version 0.17.> + +Returns a L<Future> that will become done when at least one byte has been +sent to the given filehandle (presumably a socket), by using a C<send(2)> +system call. On any error (other than C<EAGAIN> / C<EWOULDBLOCK> which are +ignored) the future fails with a suitable error message. + +Optionally a flags bitmask in C<$flags> or a destination address in C<$to> can +also be passed. If no flags are required, the value may be zero. If C<$to> is +specified then a C<sendto(2)> system call is used instead. =cut -sub syswrite_exactly +sub send { shift; - my ( $fh, $bytes ) = @_; + my ( $fh, $bytes, $flags, $to ) = @_; - $IMPL //= "Future::IO::_DefaultImpl"; + return ( $IMPL //= "Future::IO::_DefaultImpl" )->send( $fh, $bytes, $flags, $to ); +} - if( my $code = $IMPL->can( "syswrite_exactly" ) ) { - return $IMPL->$code( $fh, $bytes ); - } +=head2 sleep - return _syswrite_from_buffer( $IMPL, $fh, \$bytes, length $bytes ); -} + await Future::IO->sleep( $secs ); -sub _syswrite_from_buffer -{ - my ( $IMPL, $fh, $bufref, $len ) = @_; +Returns a L<Future> that will become done a fixed delay from now, given in +seconds. This value may be fractional. - $IMPL->syswrite( $fh, substr $$bufref, 0, $MAX_WRITELEN )->then( sub { - my ( $written_len ) = @_; - substr $$bufref, 0, $written_len, ""; +=cut - return Future->done( $len ) if !length $$bufref; - return _syswrite_from_buffer( $IMPL, $fh, $bufref, $len ); - }); +sub sleep +{ + shift; + my ( $secs ) = @_; + + return ( $IMPL //= "Future::IO::_DefaultImpl" )->sleep( $secs ); } =head2 waitpid @@ -382,6 +395,78 @@ return ( $IMPL //= "Future::IO::_DefaultImpl" )->waitpid( $pid ); } +=head2 write + + $written_len = await Future::IO->write( $fh, $bytes ); + +I<Since version 0.17.> Before this version this method used to be named +C<syswrite>, and still available via that alias. + +Returns a L<Future> that will become done when at least one byte has been +written to the given filehandle. It may write up to all of the bytes. On any +error (other than C<EAGAIN> / C<EWOULDBLOCK> which are ignored) the future +fails with a suitable error message. + +Note specifically this may perform only a single C<syswrite()> call, and thus +is not guaranteed to actually return the full length. + +=cut + +sub write +{ + shift; + my ( $fh, $bytes ) = @_; + + return ( $IMPL //= "Future::IO::_DefaultImpl" )->syswrite( $fh, $bytes ); +} + +*syswrite = \&write; + +=head2 write_exactly + + $written_len = await Future::IO->write_exactly( $fh, $bytes ); + +I<Since version 0.17.> Before this version this method used to be named +C<syswrite_exactly>, and still available via that alias. + +Returns a L<Future> that will become done when exactly the given bytes have +been written to the given filehandle. On any error (other than C<EAGAIN> / +C<EWOULDBLOCK> which are ignored) the future fails with a suitable error +message. + +This may make more than one C<syswrite()> call. + +=cut + +sub write_exactly +{ + shift; + my ( $fh, $bytes ) = @_; + + $IMPL //= "Future::IO::_DefaultImpl"; + + if( my $code = $IMPL->can( "syswrite_exactly" ) ) { + return $IMPL->$code( $fh, $bytes ); + } + + return _write_from_buffer( $IMPL, $fh, \$bytes, length $bytes ); +} + +*syswrite_exactly = \&write_exactly; + +sub _write_from_buffer +{ + my ( $IMPL, $fh, $bufref, $len ) = @_; + + $IMPL->syswrite( $fh, substr $$bufref, 0, $MAX_WRITELEN )->then( sub { + my ( $written_len ) = @_; + substr $$bufref, 0, $written_len, ""; + + return Future->done( $len ) if !length $$bufref; + return _write_from_buffer( $IMPL, $fh, $bufref, $len ); + }); +} + =head2 override_impl Future::IO->override_impl( $impl ); @@ -528,7 +613,7 @@ my $class = shift; my ( $fh ) = @_; - croak "This implementation can only cope with a single pending filehandle in ->syswrite" + croak "This implementation can only cope with a single pending filehandle in ->write" if @writers and $writers[-1]->fh != $fh; my $f = Future::IO::_DefaultImpl::F->new; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/02read.t new/Future-IO-0.17/t/02read.t --- old/Future-IO-0.16/t/02read.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/02read.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,14 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; +use Test::Future::IO::Impl; + +use Future::IO; + +run_tests 'read'; +run_tests 'sysread'; # remember to test the legacy name wrapper too + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/02sysread.t new/Future-IO-0.17/t/02sysread.t --- old/Future-IO-0.16/t/02sysread.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/02sysread.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,13 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; -use Test::Future::IO::Impl; - -use Future::IO; - -run_tests 'sysread'; - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/03read_exactly.t new/Future-IO-0.17/t/03read_exactly.t --- old/Future-IO-0.16/t/03read_exactly.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/03read_exactly.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,49 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; + +use IO::Handle; + +use Future::IO; + +# ->read_exactly yielding bytes +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + $wr->autoflush(); + $wr->print( "BYTES" ); + + my $f = Future::IO->read_exactly( $rd, 5 ); + + my @read; + no warnings 'redefine'; + local *IO::Handle::sysread = sub { + my ( $fh, undef, $len ) = @_; + push @read, $len; + return CORE::sysread( $fh, $_[1], 1 ); + }; + + is( scalar $f->get, "BYTES", 'Future::IO->read_exactly eventually yields all the bytes' ); + + is( \@read, [ 5, 4, 3, 2, 1 ], 'IO::Handle->sysread override worked' ); +} + +# ->read_exactly yielding EOF +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + $wr->autoflush(); + + my $f = Future::IO->read_exactly( $rd, 5 ); + + $wr->print( "BY" ); + $wr->close; + undef $wr; + + is( [ $f->get ], [], 'Future::IO->read_exactly yields nothing on EOF' ); +} + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/03read_until_eof.t new/Future-IO-0.17/t/03read_until_eof.t --- old/Future-IO-0.16/t/03read_until_eof.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/03read_until_eof.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,27 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; + +use IO::Handle; + +use Future::IO; + +# ->read_until_eof +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + $wr->autoflush(); + $wr->print( "BYTES" ); + + my $f = Future::IO->read_until_eof( $rd ); + + $wr->print( " HERE" ); + $wr->close; + + is( scalar $f->get, "BYTES HERE", 'Future::IO->read_until_eof eventually yields all the bytes' ); +} + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/03sysread_exactly.t new/Future-IO-0.17/t/03sysread_exactly.t --- old/Future-IO-0.16/t/03sysread_exactly.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/03sysread_exactly.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,49 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; - -use IO::Handle; - -use Future::IO; - -# ->sysread_exactly yielding bytes -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - $wr->autoflush(); - $wr->print( "BYTES" ); - - my $f = Future::IO->sysread_exactly( $rd, 5 ); - - my @read; - no warnings 'redefine'; - local *IO::Handle::sysread = sub { - my ( $fh, undef, $len ) = @_; - push @read, $len; - return CORE::sysread( $fh, $_[1], 1 ); - }; - - is( scalar $f->get, "BYTES", 'Future::IO->sysread_exactly eventually yields all the bytes' ); - - is( \@read, [ 5, 4, 3, 2, 1 ], 'IO::Handle->sysread override worked' ); -} - -# ->sysread_exactly yielding EOF -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - $wr->autoflush(); - - my $f = Future::IO->sysread_exactly( $rd, 5 ); - - $wr->print( "BY" ); - $wr->close; - undef $wr; - - is( [ $f->get ], [], 'Future::IO->sysread_exactly yields nothing on EOF' ); -} - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/03sysread_until_eof.t new/Future-IO-0.17/t/03sysread_until_eof.t --- old/Future-IO-0.16/t/03sysread_until_eof.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/03sysread_until_eof.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,27 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; - -use IO::Handle; - -use Future::IO; - -# ->sysread_until_eof -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - $wr->autoflush(); - $wr->print( "BYTES" ); - - my $f = Future::IO->sysread_until_eof( $rd ); - - $wr->print( " HERE" ); - $wr->close; - - is( scalar $f->get, "BYTES HERE", 'Future::IO->sysread_until_eof eventually yields all the bytes' ); -} - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/04syswrite.t new/Future-IO-0.17/t/04syswrite.t --- old/Future-IO-0.16/t/04syswrite.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/04syswrite.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,13 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; -use Test::Future::IO::Impl; - -use Future::IO; - -run_tests 'syswrite'; - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/04write.t new/Future-IO-0.17/t/04write.t --- old/Future-IO-0.16/t/04write.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/04write.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,14 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; +use Test::Future::IO::Impl; + +use Future::IO; + +run_tests 'write'; +run_tests 'syswrite'; # remember to test the legacy name wrapper too + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/05syswrite_exactly.t new/Future-IO-0.17/t/05syswrite_exactly.t --- old/Future-IO-0.16/t/05syswrite_exactly.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/05syswrite_exactly.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,34 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; - -use IO::Handle; - -use Future::IO; - -# ->syswrite_exactly writing bytes -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - my $f = Future::IO->syswrite_exactly( $wr, "ABC" ); - - my @written; - no warnings 'redefine'; - local *IO::Handle::syswrite = sub { - my ( $fh, $bytes ) = @_; - push @written, $bytes; - return CORE::syswrite( $fh, substr $bytes, 0, 1 ); - }; - - is( scalar $f->get, 3, 'Future::IO->syswrite_exactly eventually writes all bytes' ); - - is( \@written, [ "ABC", "BC", "C" ], 'IO::Handle->syswrite override worked' ); - - $rd->read( my $buf, 3 ); - is( $buf, "ABC", 'Future::IO->syswrite_exactly wrote bytes' ); -} - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/05write_exactly.t new/Future-IO-0.17/t/05write_exactly.t --- old/Future-IO-0.16/t/05write_exactly.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/05write_exactly.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,34 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; + +use IO::Handle; + +use Future::IO; + +# ->write_exactly writing bytes +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + my $f = Future::IO->write_exactly( $wr, "ABC" ); + + my @written; + no warnings 'redefine'; + local *IO::Handle::syswrite = sub { + my ( $fh, $bytes ) = @_; + push @written, $bytes; + return CORE::syswrite( $fh, substr $bytes, 0, 1 ); + }; + + is( scalar $f->get, 3, 'Future::IO->write_exactly eventually writes all bytes' ); + + is( \@written, [ "ABC", "BC", "C" ], 'IO::Handle->syswrite override worked' ); + + $rd->read( my $buf, 3 ); + is( $buf, "ABC", 'Future::IO->write_exactly wrote bytes' ); +} + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/08send.t new/Future-IO-0.17/t/08send.t --- old/Future-IO-0.16/t/08send.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/08send.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,13 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; +use Test::Future::IO::Impl 0.15; + +use Future::IO; + +run_tests 'send'; + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/09recv.t new/Future-IO-0.17/t/09recv.t --- old/Future-IO-0.16/t/09recv.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/09recv.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,14 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; +use Test::Future::IO::Impl 0.15; + +use Future::IO; + +run_tests 'recv'; +run_tests 'recvfrom'; + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/10sleep+read.t new/Future-IO-0.17/t/10sleep+read.t --- old/Future-IO-0.16/t/10sleep+read.t 1970-01-01 01:00:00.000000000 +0100 +++ new/Future-IO-0.17/t/10sleep+read.t 2025-07-15 21:45:32.000000000 +0200 @@ -0,0 +1,41 @@ +#!/usr/bin/perl + +use v5.14; +use warnings; + +use Test2::V0; + +use IO::Handle; + +use Future::IO; + +plan skip_all => "Cannot select() on pipes on Windows" if $^O eq "MSWin32"; + +# sleep + read IO ready +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + $wr->autoflush(); + $wr->print( "BYTES" ); + + my $f = Future->needs_any( + Future::IO->read( $rd, 5 ), + Future::IO->sleep( 2 ), + ); + + is( scalar $f->get, "BYTES", 'Future::IO ->sleep ->read concurrently yields bytes' ); +} + +# sleep + read timeout +{ + pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; + + my $f = Future->needs_any( + Future::IO->read( $rd, 5 ), + Future::IO->sleep( 0.2 )->then_done( "timeout" ), + ); + + is( scalar $f->get, "timeout", 'Future::IO ->sleep ->read concurrently yields timeout' ); +} + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/10sleep+sysread.t new/Future-IO-0.17/t/10sleep+sysread.t --- old/Future-IO-0.16/t/10sleep+sysread.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/10sleep+sysread.t 1970-01-01 01:00:00.000000000 +0100 @@ -1,41 +0,0 @@ -#!/usr/bin/perl - -use v5.14; -use warnings; - -use Test2::V0; - -use IO::Handle; - -use Future::IO; - -plan skip_all => "Cannot select() on pipes on Windows" if $^O eq "MSWin32"; - -# sleep + sysread IO ready -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - $wr->autoflush(); - $wr->print( "BYTES" ); - - my $f = Future->needs_any( - Future::IO->sysread( $rd, 5 ), - Future::IO->sleep( 2 ), - ); - - is( scalar $f->get, "BYTES", 'Future::IO ->sleep ->sysread concurrently yields bytes' ); -} - -# sleep + sysread timeout -{ - pipe my ( $rd, $wr ) or die "Cannot pipe() - $!"; - - my $f = Future->needs_any( - Future::IO->sysread( $rd, 5 ), - Future::IO->sleep( 0.2 )->then_done( "timeout" ), - ); - - is( scalar $f->get, "timeout", 'Future::IO ->sleep ->sysread concurrently yields timeout' ); -} - -done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/20impl-override.t new/Future-IO-0.17/t/20impl-override.t --- old/Future-IO-0.16/t/20impl-override.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/20impl-override.t 2025-07-15 21:45:32.000000000 +0200 @@ -37,14 +37,14 @@ $f->cancel; } -# sysread +# read { $impl_f = Future->new; - my $f = Future::IO->sysread( "FH", 1024 ); + my $f = Future::IO->read( "FH", 1024 ); - is( \@impl_args, [ "FH", 1024 ], '->sysread args' ); - ref_is( $f, $impl_f, '->sysread return' ); + is( \@impl_args, [ "FH", 1024 ], '->read args' ); + ref_is( $f, $impl_f, '->read return' ); $f->cancel; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Future-IO-0.16/t/90rt150117.t new/Future-IO-0.17/t/90rt150117.t --- old/Future-IO-0.16/t/90rt150117.t 2024-09-16 19:02:27.000000000 +0200 +++ new/Future-IO-0.17/t/90rt150117.t 2025-07-15 21:45:32.000000000 +0200 @@ -44,7 +44,7 @@ my ( $controller, $puppet ) = Test::ExpectAndCheck->create; -# ->sysread does not build long future chains on EAGAIN +# ->read does not build long future chains on EAGAIN { my $read_f; @@ -70,12 +70,12 @@ return length $args->[0]; }); - $read_f = Future::IO->sysread( $puppet, 128 ); - is( $read_f->get, "result", '->sysread yields result' ); + $read_f = Future::IO->read( $puppet, 128 ); + is( $read_f->get, "result", '->read yields result' ); - is( $dep_count, 1, '->sysread future did not build a big dependent chain' ); + is( $dep_count, 1, '->read future did not build a big dependent chain' ); - $controller->check_and_clear( '->sysread' ); + $controller->check_and_clear( '->read' ); } done_testing; ++++++ README.md ++++++ ## Build Results Current state of perl in openSUSE:Factory is  The current state of perl in the devel project build (devel:languages:perl)  ++++++ _scmsync.obsinfo ++++++ mtime: 1755898448 commit: 8c25dadec4bcf01a9e39df260730342a384fe8f01518709bb208e77885a79cdb url: https://src.opensuse.org/perl/perl-Future-IO.git revision: 8c25dadec4bcf01a9e39df260730342a384fe8f01518709bb208e77885a79cdb projectscmsync: https://src.opensuse.org/perl/_ObsPrj ++++++ build.specials.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.gitignore new/.gitignore --- old/.gitignore 1970-01-01 01:00:00.000000000 +0100 +++ new/.gitignore 2025-08-26 15:53:39.000000000 +0200 @@ -0,0 +1 @@ +.osc
