[perl-SOAP-Lite] Bundle 0.714 IO modules to fix dependency breakage

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



commit efaa4364498f9d9a18773ef283df6cce9d3fd6a1
Author: Petr Šabata <contyk@xxxxxxxxxx>
Date:   Thu Aug 2 17:15:45 2012 +0200

    Bundle 0.714 IO modules to fix dependency breakage

 perl-SOAP-Lite-0.715-IO-modules.patch |  425 +++++++++++++++++++++++++++++++++
 perl-SOAP-Lite.spec                   |    9 +-
 2 files changed, 433 insertions(+), 1 deletions(-)
---
diff --git a/perl-SOAP-Lite-0.715-IO-modules.patch b/perl-SOAP-Lite-0.715-IO-modules.patch
new file mode 100644
index 0000000..8c7c9fc
--- /dev/null
+++ b/perl-SOAP-Lite-0.715-IO-modules.patch
@@ -0,0 +1,425 @@
+From e5091cc065b492cfaba9896cb488035e291555e6 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Petr=20=C5=A0abata?= <contyk@xxxxxxxxxx>
+Date: Thu, 2 Aug 2012 17:10:04 +0200
+Subject: [PATCH] Add IO::SessionDat and IO::SessionSet from SOAP::Lite 0.714
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+
+Signed-off-by: Petr Šabata <contyk@xxxxxxxxxx>
+---
+ lib/IO/SessionData.pm |  230 +++++++++++++++++++++++++++++++++++++++++++++++++
+ lib/IO/SessionSet.pm  |  163 ++++++++++++++++++++++++++++++++++
+ 2 files changed, 393 insertions(+), 0 deletions(-)
+ create mode 100644 lib/IO/SessionData.pm
+ create mode 100644 lib/IO/SessionSet.pm
+
+diff --git a/lib/IO/SessionData.pm b/lib/IO/SessionData.pm
+new file mode 100644
+index 0000000..de85382
+--- /dev/null
++++ b/lib/IO/SessionData.pm
+@@ -0,0 +1,230 @@
++# ======================================================================
++#
++# Copyright (C) 2000 Lincoln D. Stein
++# Slightly modified by Paul Kulchenko to work on multiple platforms
++# Formatting changed to match the layout layed out in Perl Best Practices
++# (by Damian Conway) by Martin Kutter in 2008
++#
++# ======================================================================
++
++package IO::SessionData;
++
++use strict;
++use Carp;
++use IO::SessionSet;
++use vars '$VERSION';
++$VERSION = 1.02;
++
++use constant BUFSIZE => 3000;
++
++BEGIN {
++    my @names = qw(EWOULDBLOCK EAGAIN EINPROGRESS);
++    my %WOULDBLOCK =
++        (eval {require Errno}
++            ? map {
++                Errno->can($_)
++                    ? (Errno->can($_)->() => 1)
++                    : (),
++                } @names
++            : ()
++        ),
++        (eval {require POSIX}
++            ? map {
++                POSIX->can($_) && eval { POSIX->can($_)->() }
++                ? (POSIX->can($_)->() => 1)
++                    : ()
++                } @names
++            : ()
++        );
++
++    sub WOULDBLOCK { $WOULDBLOCK{$_[0]+0} }
++}
++
++# Class method: new()
++# Create a new IO::SessionData object.  Intended to be called from within
++# IO::SessionSet, not directly.
++sub new {
++    my $pack = shift;
++    my ($sset,$handle,$writeonly) = @_;
++    # make the handle nonblocking (but check for 'blocking' method first)
++    # thanks to Jos Clijmans <jos.clijmans@xxxxxxxxxx>
++    $handle->blocking(0) if $handle->can('blocking');
++    my $self = bless {
++        outbuffer   => '',
++        sset        => $sset,
++        handle      => $handle,
++        write_limit => BUFSIZE,
++        writeonly   => $writeonly,
++        choker      => undef,
++        choked      => 0,
++    },$pack;
++    $self->readable(1) unless $writeonly;
++    return $self;
++}
++
++# Object method: handle()
++# Return the IO::Handle object corresponding to this IO::SessionData
++sub handle {
++    return shift->{handle};
++}
++
++# Object method: sessions()
++# Return the IO::SessionSet controlling this object.
++sub sessions {
++    return shift->{sset};
++}
++
++# Object method: pending()
++# returns number of bytes pending in the out buffer
++sub pending {
++    return length shift->{outbuffer};
++}
++
++# Object method: write_limit([$bufsize])
++# Get or set the limit on the size of the write buffer.
++# Write buffer will grow to this size plus whatever extra you write to it.
++sub write_limit {
++    my $self = shift;
++    return defined $_[0]
++        ? $self->{write_limit} = $_[0]
++        : $self->{write_limit};
++}
++
++# set a callback to be called when the contents of the write buffer becomes larger
++# than the set limit.
++sub set_choke {
++    my $self = shift;
++    return defined $_[0]
++        ? $self->{choker} = $_[0]
++        : $self->{choker};
++}
++
++# Object method: write($scalar)
++# $obj->write([$data]) -- append data to buffer and try to write to handle
++# Returns number of bytes written, or 0E0 (zero but true) if data queued but not
++# written. On other errors, returns undef.
++sub write {
++    my $self = shift;
++    return unless my $handle = $self->handle; # no handle
++    return unless defined $self->{outbuffer}; # no buffer for queued data
++
++    $self->{outbuffer} .= $_[0] if defined $_[0];
++
++    my $rc;
++    if ($self->pending) { # data in the out buffer to write
++        local $SIG{PIPE}='IGNORE';
++        # added length() to make it work on Mac. Thanks to Robin Fuller <rfuller@xxxxxxxxxxxxx>
++        $rc = syswrite($handle,$self->{outbuffer},length($self->{outbuffer}));
++
++        # able to write, so truncate out buffer apropriately
++        if ($rc) {
++            substr($self->{outbuffer},0,$rc) = '';
++        }
++        elsif (WOULDBLOCK($!)) {  # this is OK
++            $rc = '0E0';
++        }
++        else { # some sort of write error, such as a PIPE error
++            return $self->bail_out($!);
++        }
++    }
++    else {
++        $rc = '0E0';   # nothing to do, but no error either
++    }
++
++    $self->adjust_state;
++
++    # Result code is the number of bytes successfully transmitted
++    return $rc;
++}
++
++# Object method: read($scalar,$length [,$offset])
++# Just like sysread(), but returns the number of bytes read on success,
++# 0EO ("0 but true") if the read would block, and undef on EOF and other failures.
++sub read {
++    my $self = shift;
++    return unless my $handle = $self->handle;
++    my $rc = sysread($handle,$_[0],$_[1],$_[2]||0);
++    return $rc if defined $rc;
++    return '0E0' if WOULDBLOCK($!);
++    return;
++}
++
++# Object method: close()
++# Close the session and remove it from the monitored list.
++sub close {
++    my $self = shift;
++    unless ($self->pending) {
++        $self->sessions->delete($self);
++        CORE::close($self->handle);
++    }
++    else {
++        $self->readable(0);
++        $self->{closing}++;  # delayed close
++    }
++}
++
++# Object method: adjust_state()
++# Called periodically from within write() to control the
++# status of the handle on the IO::SessionSet's IO::Select sets
++sub adjust_state {
++    my $self = shift;
++
++    # make writable if there's anything in the out buffer
++    $self->writable($self->pending > 0);
++
++    # make readable if there's no write limit, or the amount in the out
++    # buffer is less than the write limit.
++    $self->choke($self->write_limit <= $self->pending) if $self->write_limit;
++
++    # Try to close down the session if it is flagged
++    # as in the closing state.
++    $self->close if $self->{closing};
++}
++
++# choke gets called when the contents of the write buffer are larger
++# than the limit.  The default action is to inactivate the session for further
++# reading until the situation is cleared.
++sub choke {
++    my $self = shift;
++    my $do_choke = shift;
++    return if $self->{choked} == $do_choke;  # no change in state
++    if (ref $self->set_choke eq 'CODE') {
++        $self->set_choke->($self,$do_choke);
++    }
++    else {
++        $self->readable(!$do_choke);
++    }
++    $self->{choked} = $do_choke;
++}
++
++# Object method: readable($flag)
++# Flag the associated IO::SessionSet that we want to do reading on the handle.
++sub readable {
++    my $self = shift;
++    my $is_active = shift;
++    return if $self->{writeonly};
++    $self->sessions->activate($self,'read',$is_active);
++}
++
++# Object method: writable($flag)
++# Flag the associated IO::SessionSet that we want to do writing on the handle.
++sub writable {
++    my $self = shift;
++    my $is_active = shift;
++    $self->sessions->activate($self,'write',$is_active);
++}
++
++# Object method: bail_out([$errcode])
++# Called when an error is encountered during writing (such as a PIPE).
++# Default behavior is to flush all buffered outgoing data and to close
++# the handle.
++sub bail_out {
++    my $self = shift;
++    my $errcode = shift;           # save errorno
++    delete $self->{outbuffer};     # drop buffered data
++    $self->close;
++    $! = $errcode;                 # restore errno
++    return;
++}
++
++1;
+diff --git a/lib/IO/SessionSet.pm b/lib/IO/SessionSet.pm
+new file mode 100644
+index 0000000..ae6e4fe
+--- /dev/null
++++ b/lib/IO/SessionSet.pm
+@@ -0,0 +1,163 @@
++# ======================================================================
++#
++# Copyright (C) 2000 Lincoln D. Stein
++# Formatting changed to match the layout layed out in Perl Best Practices
++# (by Damian Conway) by Martin Kutter in 2008
++#
++# ======================================================================
++
++package IO::SessionSet;
++
++use strict;
++use Carp;
++use IO::Select;
++use IO::Handle;
++use IO::SessionData;
++
++use vars '$DEBUG';
++$DEBUG = 0;
++
++# Class method new()
++# Create a new Session set.
++# If passed a listening socket, use that to
++# accept new IO::SessionData objects automatically.
++sub new {
++    my $pack = shift;
++    my $listen = shift;
++    my $self = bless {
++        sessions     => {},
++        readers      => IO::Select->new(),
++        writers      => IO::Select->new(),
++        }, $pack;
++    # if initialized with an IO::Handle object (or subclass)
++    # then we treat it as a listening socket.
++    if ( defined($listen) and $listen->can('accept') ) {
++        $self->{listen_socket} = $listen;
++        $self->{readers}->add($listen);
++    }
++    return $self;
++}
++
++# Object method: sessions()
++# Return list of all the sessions currently in the set.
++sub sessions {
++    return values %{shift->{sessions}}
++};
++
++# Object method: add()
++# Add a handle to the session set.  Will automatically
++# create a IO::SessionData wrapper around the handle.
++sub add {
++    my $self = shift;
++    my ($handle,$writeonly) = @_;
++    warn "Adding a new session for $handle.\n" if $DEBUG;
++    return $self->{sessions}{$handle} =
++        $self->SessionDataClass->new($self,$handle,$writeonly);
++}
++
++# Object method: delete()
++# Remove a session from the session set.  May pass either a handle or
++# a corresponding IO::SessionData wrapper.
++sub delete {
++    my $self = shift;
++    my $thing = shift;
++    my $handle = $self->to_handle($thing);
++    my $sess = $self->to_session($thing);
++    warn "Deleting session $sess handle $handle.\n" if $DEBUG;
++    delete $self->{sessions}{$handle};
++    $self->{readers}->remove($handle);
++    $self->{writers}->remove($handle);
++}
++
++# Object method: to_handle()
++# Return a handle, given either a handle or a IO::SessionData object.
++sub to_handle {
++    my $self = shift;
++    my $thing = shift;
++    return $thing->handle if $thing->isa('IO::SessionData');
++    return $thing if defined (fileno $thing);
++    return;  # undefined value
++}
++
++# Object method: to_session
++# Return a IO::SessionData object, given either a handle or the object itself.
++sub to_session {
++    my $self = shift;
++    my $thing = shift;
++    return $thing if $thing->isa('IO::SessionData');
++    return $self->{sessions}{$thing} if defined (fileno $thing);
++    return;  # undefined value
++}
++
++# Object method: activate()
++# Called with parameters ($session,'read'|'write' [,$activate])
++# If called without the $activate argument, will return true
++# if the indicated handle is on the read or write IO::Select set.
++# May use either a session object or a handle as first argument.
++sub activate {
++    my $self = shift;
++    my ($thing,$rw,$act) = @_;
++    croak 'Usage $obj->activate($session,"read"|"write" [,$activate])'
++        unless @_ >= 2;
++    my $handle = $self->to_handle($thing);
++    my $select = lc($rw) eq 'read' ? 'readers' : 'writers';
++    my $prior = defined $self->{$select}->exists($handle);
++    if (defined $act && $act != $prior) {
++        $self->{$select}->add($handle)        if $act;
++        $self->{$select}->remove($handle) unless $act;
++        warn $act ? 'Activating' : 'Inactivating',
++            " handle $handle for ",
++            $rw eq 'read' ? 'reading':'writing',".\n" if $DEBUG;
++    }
++    return $prior;
++}
++
++# Object method: wait()
++# Wait for I/O.  Handles writes automatically.  Returns a list of
++# IO::SessionData objects ready for reading.
++# If there is a listen socket, then will automatically do an accept()
++# and return a new IO::SessionData object for that.
++sub wait {
++    my $self = shift;
++    my $timeout = shift;
++
++    # Call select() to get the list of sessions that are ready for
++    # reading/writing.
++    warn "IO::Select->select() returned error: $!"
++        unless my ($read,$write) =
++            IO::Select->select($self->{readers},$self->{writers},undef,$timeout);
++
++    # handle queued writes automatically
++    foreach (@$write) {
++        my $session = $self->to_session($_);
++        warn "Writing pending data (",$session->pending+0," bytes) for $_.\n"
++            if $DEBUG;
++        my $rc = $session->write;
++    }
++
++    # Return list of sessions that are ready for reading.
++    # If one of the ready handles is the listen socket, then
++    # create a new session.
++    # Otherwise return the ready handles as a list of IO::SessionData objects.
++    my @sessions;
++    foreach (@$read) {
++        if ($_ eq $self->{listen_socket}) {
++            my $newhandle = $_->accept;
++            warn "Accepting a new handle $newhandle.\n" if $DEBUG;
++            my $newsess = $self->add($newhandle) if $newhandle;
++            push @sessions,$newsess;
++        }
++        else {
++            push @sessions,$self->to_session($_);
++        }
++    }
++    return @sessions;
++}
++
++# Class method: SessionDataClass
++# Return the string containing the name of the session data
++# wrapper class.  Subclass and override to use a different
++# session data class.
++sub SessionDataClass {  return 'IO::SessionData'; }
++
++1;
+-- 
+1.7.7.6
+
diff --git a/perl-SOAP-Lite.spec b/perl-SOAP-Lite.spec
index 1b6c5d0..25a86a4 100644
--- a/perl-SOAP-Lite.spec
+++ b/perl-SOAP-Lite.spec
@@ -1,11 +1,12 @@
 Name:       perl-SOAP-Lite
 Version:    0.715
-Release:    1%{?dist}
+Release:    2%{?dist}
 Summary:    Client and server side SOAP implementation
 License:    GPL+ or Artistic
 Group:      Development/Libraries
 URL:        http://search.cpan.org/dist/SOAP-Lite/
 Source0:    http://search.cpan.org/CPAN/authors/id/M/MK/MKUTTER/SOAP-Lite-%{version}.tar.gz
+Patch0:     perl-SOAP-Lite-0.715-IO-modules.patch
 BuildArch:  noarch
 
 # Core package
@@ -65,6 +66,7 @@ client and server side.
 
 %prep
 %setup -q -n SOAP-Lite-%{version}
+%patch0 -p1 -b .IO
 find examples -type f -exec chmod ugo-x {} \;
 
 %build
@@ -85,6 +87,7 @@ make test
 %{_bindir}/*pl
 %{perl_vendorlib}/SOAP
 %{perl_vendorlib}/Apache
+%{perl_vendorlib}/IO
 %{perl_vendorlib}/UDDI
 %{perl_vendorlib}/XML
 %{perl_vendorlib}/XMLRPC
@@ -92,6 +95,10 @@ make test
 %{_mandir}/man1/*
 
 %changelog
+* Thu Aug 02 2012 Petr Šabata <contyk@xxxxxxxxxx> - 0.715-2
+- Bundle 0.714 IO modules to fix dependency breakage
+  (confirmed as unintentional by upstream)
+
 * Thu Jul 19 2012 Petr Šabata <contyk@xxxxxxxxxx> - 0.715-1
 - 0.715 bump
 - Drop command macros
--
Fedora Extras Perl SIG
http://www.fedoraproject.org/wiki/Extras/SIGs/Perl
perl-devel mailing list
perl-devel@xxxxxxxxxxxxxxxxxxxxxxx
https://admin.fedoraproject.org/mailman/listinfo/perl-devel



[Index of Archives]     [Fedora Announce]     [Fedora Kernel]     [Fedora Testing]     [Fedora Legacy Announce]     [Fedora PHP Devel]     [Kernel Devel]     [Fedora Legacy]     [Fedora Maintainers]     [Fedora Desktop]     [PAM]     [Red Hat Development]     [Big List of Linux Books]     [Gimp]     [Yosemite Information]
  Powered by Linux