From c1f02b6695a30c27e3122b702497faa6ee463a3a Mon Sep 17 00:00:00 2001 From: ertaozh Date: Mon, 21 Mar 2016 04:37:48 -0400 Subject: [PATCH] Add perl-Net-HTTPS-NB and perl-HTTP-Async into xcat-dep --- perl-HTTP-Async/Build-note | 16 + perl-HTTP-Async/HTTP-Async-0.30.patch | 1584 ++++++++++++++++++++ perl-HTTP-Async/HTTP-Async-0.30.tar.gz | Bin 0 -> 24508 bytes perl-HTTP-Async/perl-HTTP-Async.spec | 143 ++ perl-Net-HTTPS-NB/Build-note | 16 + perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.patch | 197 +++ perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.tar.gz | Bin 0 -> 5777 bytes perl-Net-HTTPS-NB/perl-Net-HTTPS-NB.spec | 96 ++ 8 files changed, 2052 insertions(+) create mode 100644 perl-HTTP-Async/Build-note create mode 100644 perl-HTTP-Async/HTTP-Async-0.30.patch create mode 100644 perl-HTTP-Async/HTTP-Async-0.30.tar.gz create mode 100644 perl-HTTP-Async/perl-HTTP-Async.spec create mode 100644 perl-Net-HTTPS-NB/Build-note create mode 100644 perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.patch create mode 100644 perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.tar.gz create mode 100644 perl-Net-HTTPS-NB/perl-Net-HTTPS-NB.spec diff --git a/perl-HTTP-Async/Build-note b/perl-HTTP-Async/Build-note new file mode 100644 index 0000000..e7ae2d1 --- /dev/null +++ b/perl-HTTP-Async/Build-note @@ -0,0 +1,16 @@ +Build Notes + +1. To build rpm +1) copy HTTP-Async-0.30.patch and HTTP-Async-0.30.tar.gz into /root/rpmbuild/SOURCES +2) copy perl-HTTP-Async.spec into /root/rpmbuild/SPECS +3) rpmbuild -ba /root/rpmbuild/SPECS/perl-HTTP-Async.spec +4) The rpm package is located at /root/rpmbuild/RPMS/noarch/perl-HTTP-Async-0.30-2.noarch.rpm + +2. To build .deb package +1) Install 'alien' on the build machine +2) Create a temparary directory such as /tmp/perl-HTTP-Async, and copy the perl-HTTP-Async-0.30-2.noarch.rpm package into it +3) Use the command "alien -k --scripts -s perl-HTTP-Async-0.30-2.noarch.rpm" to generate debian packaging related files. + It will generate a directory like ./perl-HTTP-Async-0.30 +3) cd perl-HTTP-Async-0.30; mv usr/local/share/ usr/; rmdir usr/local/ +4) dpkg-buildpackage -uc -us +5) The .deb package perl-http-async_0.30-2_all.deb will be located at /tmp/perl-HTTP-Async diff --git a/perl-HTTP-Async/HTTP-Async-0.30.patch b/perl-HTTP-Async/HTTP-Async-0.30.patch new file mode 100644 index 0000000..a3b677b --- /dev/null +++ b/perl-HTTP-Async/HTTP-Async-0.30.patch @@ -0,0 +1,1584 @@ +diff -Nur HTTP-Async-0.30/Makefile.PL HTTP-Async-0.30_mod/Makefile.PL +--- HTTP-Async-0.30/Makefile.PL 2015-06-02 02:27:03.000000000 -0400 ++++ HTTP-Async-0.30_mod/Makefile.PL 2016-03-14 00:27:17.000000000 -0400 +@@ -7,26 +7,6 @@ + 'NAME' => 'HTTP::Async', + 'VERSION_FROM' => 'lib/HTTP/Async.pm', + LICENSE => 'perl', +- 'PREREQ_PM' => { +- 'Carp' => 0, +- 'Data::Dumper' => 0, +- 'HTTP::Request' => 0, +- 'HTTP::Response' => 0, +- 'HTTP::Server::Simple::CGI' => 0, +- 'HTTP::Status' => 0, +- 'IO::Select' => 0, +- 'LWP::UserAgent' => 0, +- 'Net::HTTP' => 0, +- 'Net::HTTP::NB' => 0, +- 'Net::HTTPS::NB' => 0.13, +- 'Test::HTTP::Server::Simple' => 0, +- 'Test::More' => 0, +- 'Test::Fatal' => 0, +- 'Time::HiRes' => 0, +- 'URI' => 0, +- 'URI::Escape' => 0, +- 'Net::EmptyPort' => 0, +- }, + META_MERGE => { + resources => { + repository => 'https://github.com/evdb/HTTP-Async', +diff -Nur HTTP-Async-0.30/MANIFEST HTTP-Async-0.30_mod/MANIFEST +--- HTTP-Async-0.30/MANIFEST 2015-09-28 12:13:01.000000000 -0400 ++++ HTTP-Async-0.30_mod/MANIFEST 2016-03-14 00:26:47.000000000 -0400 +@@ -5,34 +5,6 @@ + Makefile.PL + MANIFEST This list of files + README.md +-t/bad-connections.t +-t/bad-headers.t +-t/bad-hosts.t +-t/cookies.t +-t/dead-connection.t +-t/headers.t +-t/invalid-options.t +-t/key_aliases.t +-t/local-addr.t +-t/make-url-absolute.t +-t/not-modified.t +-t/peer-addr.t +-t/pod-coverage.t +-t/pod.t +-t/polite.t +-t/poll-interval.t +-t/proxy-with-https.t +-t/proxy.t +-t/real-servers.t +-t/redirects.t +-t/release-cpan-changes.t +-t/remove.t +-t/setup.t +-t/strip-host-from-uri.t +-t/template.t +-t/test-utils.pl +-t/TestServer.pm +-t/timeout.t + TODO + META.yml Module YAML meta-data (added by MakeMaker) + META.json Module JSON meta-data (added by MakeMaker) +diff -Nur HTTP-Async-0.30/META.json HTTP-Async-0.30_mod/META.json +--- HTTP-Async-0.30/META.json 2015-09-28 12:13:01.000000000 -0400 ++++ HTTP-Async-0.30_mod/META.json 2016-03-14 00:28:28.000000000 -0400 +@@ -29,28 +29,6 @@ + "requires" : { + "ExtUtils::MakeMaker" : "0" + } +- }, +- "runtime" : { +- "requires" : { +- "Carp" : "0", +- "Data::Dumper" : "0", +- "HTTP::Request" : "0", +- "HTTP::Response" : "0", +- "HTTP::Server::Simple::CGI" : "0", +- "HTTP::Status" : "0", +- "IO::Select" : "0", +- "LWP::UserAgent" : "0", +- "Net::EmptyPort" : "0", +- "Net::HTTP" : "0", +- "Net::HTTP::NB" : "0", +- "Net::HTTPS::NB" : "0.13", +- "Test::Fatal" : "0", +- "Test::HTTP::Server::Simple" : "0", +- "Test::More" : "0", +- "Time::HiRes" : "0", +- "URI" : "0", +- "URI::Escape" : "0" +- } + } + }, + "release_status" : "stable", +diff -Nur HTTP-Async-0.30/META.yml HTTP-Async-0.30_mod/META.yml +--- HTTP-Async-0.30/META.yml 2015-09-28 12:13:01.000000000 -0400 ++++ HTTP-Async-0.30_mod/META.yml 2016-03-14 00:28:52.000000000 -0400 +@@ -15,27 +15,7 @@ + name: HTTP-Async + no_index: + directory: +- - t + - inc +-requires: +- Carp: '0' +- Data::Dumper: '0' +- HTTP::Request: '0' +- HTTP::Response: '0' +- HTTP::Server::Simple::CGI: '0' +- HTTP::Status: '0' +- IO::Select: '0' +- LWP::UserAgent: '0' +- Net::EmptyPort: '0' +- Net::HTTP: '0' +- Net::HTTP::NB: '0' +- Net::HTTPS::NB: '0.13' +- Test::Fatal: '0' +- Test::HTTP::Server::Simple: '0' +- Test::More: '0' +- Time::HiRes: '0' +- URI: '0' +- URI::Escape: '0' + resources: + repository: https://github.com/evdb/HTTP-Async + version: '0.30' +diff -Nur HTTP-Async-0.30/t/bad-connections.t HTTP-Async-0.30_mod/t/bad-connections.t +--- HTTP-Async-0.30/t/bad-connections.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/bad-connections.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,25 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 5; +-use HTTP::Request; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-my %tests = ( +- "$url_root/foo/bar?break_connection=before_headers" => 504, +- "$url_root/foo/bar?break_connection=before_content" => 200, +-); +- +-while ( my ( $url, $code ) = each %tests ) { +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, $code, "Got a '$code' response"; +-} +diff -Nur HTTP-Async-0.30/t/bad-headers.t HTTP-Async-0.30_mod/t/bad-headers.t +--- HTTP-Async-0.30/t/bad-headers.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/bad-headers.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,23 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 3; +-use HTTP::Request; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-# Check that a couple of redirects work. +-my $url = "$url_root/foo/bar?bad_header=1"; +- +-my $req = HTTP::Request->new( 'GET', $url ); +-ok $q->add($req), "Added request to the queue"; +-$q->poke while !$q->to_return_count; +- +-my $res = $q->next_response; +-is $res->code, 200, "Got a response"; +diff -Nur HTTP-Async-0.30/t/bad-hosts.t HTTP-Async-0.30_mod/t/bad-hosts.t +--- HTTP-Async-0.30/t/bad-hosts.t 2015-03-15 11:17:52.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/bad-hosts.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,52 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More; +- +-use HTTP::Request; +-use LWP::UserAgent; +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-# Some weird ISPs or DNS providers take an address like http://i.dont.exist/ +-# and resolve it to something "useful" such as +-# http://navigationshilfe1.t-online.de/dnserror?url=http://i.dont.exist/ +-# +-# If that's happening then let's just give up on this test entirely. +-{ +- my $ua = LWP::UserAgent->new; +- if ($ua->get('http://i.dont.exist/foo/bar')->is_success) { +- plan skip_all => 'http://i.dont.exist/foo/bar resolved to something!'; +- exit; +- } +-} +- +-# Try to add some requests for bad hosts. HTTP::Async should not fail +-# but should return HTTP::Responses with the correct status code etc. +- +-plan tests => 9; +- +-my @bad_requests = +- map { HTTP::Request->new( GET => $_ ) } +- ( 'http://i.dont.exist/foo/bar', 'ftp://wrong.protocol.com/foo/bar' ); +- +-ok $q->add(@bad_requests), "Added bad requests"; +- +-while ( $q->not_empty ) { +- my $res = $q->next_response || next; +- +- my $request_uri = $res->request->uri; +- +- isa_ok($res, 'HTTP::Response', "$request_uri - Got a proper response") +- || diag sprintf("ref: %s", ref $res); +- +- ok(!$res->is_success, "$request_uri - Response was not a success") +- || diag sprintf("%s: %s", $res->code, $res->decoded_content); +- +- ok($res->is_error, "$request_uri - Response was an error") +- || diag sprintf("%s: %s", $res->code, $res->decoded_content); +- +- ok $res->request, "$request_uri - Response has a request attached"; +-} +diff -Nur HTTP-Async-0.30/t/cookies.t HTTP-Async-0.30_mod/t/cookies.t +--- HTTP-Async-0.30/t/cookies.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/cookies.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,32 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 4; +-use HTTP::Request; +-use HTTP::Cookies; +-use HTTP::Async; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-my $q = HTTP::Async->new; +- +-my $cookie_jar = HTTP::Cookies->new({}); +-$q->cookie_jar($cookie_jar); +- +-# Receive a cookie and store it in a cookie jar +-{ +- my $url = "$url_root/foo/bar?cookie=1"; +- +- my $req = HTTP::Request->new('GET', $url); +- ok $q->add($req), "Added request to the queue"; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- my $response_cookie = $res->header('Set-Cookie'); +- ok $response_cookie =~ m/x=test/, "Got cookie in response '$response_cookie'"; +- +- my $jar_cookie = $cookie_jar->as_string(); +- ok $jar_cookie =~ m/x=test/, "Got cookie from cookie jar '$jar_cookie'"; +-} +diff -Nur HTTP-Async-0.30/t/dead-connection.t HTTP-Async-0.30_mod/t/dead-connection.t +--- HTTP-Async-0.30/t/dead-connection.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/dead-connection.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,67 +0,0 @@ +-# Hello Edmund, +-# +-# Thanks for HTTP::Async! I have a question about it, that I cannot figure out +-# myself. I'm playing with HTTP::Async in various corner cases, and there's one +-# particular error I'm getting: +-# +-# HTTP::Async object destroyed but still in use at a.pl line 0 +-# HTTP::Async INTERNAL ERROR: 'id_opts' not empty at a.pl line 0 +-# +-# and the code is +- +-use strict; +-use warnings; +-use HTTP::Async; +-use HTTP::Request; +-use IO::Socket::INET; +-use Time::HiRes; +-use Net::EmptyPort (); +- +-use Test::More tests => 10; +- +-my $port = Net::EmptyPort::empty_port(); +-my $abort_period = 3; +- +-foreach my $arg_key (qw(timeout max_request_time)) { +- +- # open a socket that will accept connections but never respond +- my $sock = IO::Socket::INET->new( +- Listen => 5, +- LocalAddr => 'localhost', +- LocalPort => $port, +- Proto => 'tcp' +- ) || die "Could not open a socket on port '$port' - maybe in use?"; +- ok $sock, "opened socket on port '$port'"; +- +- my $async = HTTP::Async->new( $arg_key => $abort_period ); +- ok $async, "creating async using $arg_key => $abort_period"; +- +- my $req = HTTP::Request->new( GET => "http://localhost:$port/" ); +- my $id = $async->add($req); +- ok $id, "Added request, given id '$id'"; +- +- # set up time started and when it should end. Add one second to be generous. +- my $added_time = time; +- my $should_end_time = $added_time + $abort_period + 1; +- +- my $res = undef; +- +- while (!$res) { +- $res = $async->wait_for_next_response(1); +- +- # Check that we have not been waiting too long. +- last if time > $should_end_time; +- } +- +- ok $res, "got a response"; +- is $res->code, 504, "got faked up timeout response"; +-} +- +-# I expected that $response should be defined and contain a fake 504 error. +-# It's either I'm doing something wrong or ..? +-# +-# +-# -- +-# Sincerely, +-# +-# Dmitry Karasik +diff -Nur HTTP-Async-0.30/t/headers.t HTTP-Async-0.30_mod/t/headers.t +--- HTTP-Async-0.30/t/headers.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/headers.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,21 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 3; +-use HTTP::Request; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-my $req = HTTP::Request->new( 'GET', "$url_root?delay=0" ); +-$req->header( 'Cookie', 'foo=bar' ); +- +-ok $q->add($req), "Added request to the queue"; +-$q->poke while !$q->to_return_count; +- +-my $res = $q->next_response; +-is $res->code, 200, "Got a response"; +diff -Nur HTTP-Async-0.30/t/invalid-options.t HTTP-Async-0.30_mod/t/invalid-options.t +--- HTTP-Async-0.30/t/invalid-options.t 2015-06-02 02:27:03.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/invalid-options.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,40 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 2; +-use Test::Fatal; +- +-use HTTP::Async; +-use HTTP::Request; +- +-{ +- like( +- exception { +- HTTP::Async->new( +- proxy_addr => "localhost", +- proxy_port => 12345, +- ) +- }, +- qr/proxy_addr not valid/, +- 'new dies on invalid option.' +- ); +-} +- +-{ +- my $q = HTTP::Async->new; +- my $r = HTTP::Request->new; +- +- like( +- exception { +- $q->add_with_opts($r, { +- proxy_addr => "localhost", +- proxy_port => 12345, +- }) +- }, +- qr/proxy_addr not valid/, +- 'add_with_opts dies on invalid option.' +- ); +-} +- +-1; +- +diff -Nur HTTP-Async-0.30/t/key_aliases.t HTTP-Async-0.30_mod/t/key_aliases.t +--- HTTP-Async-0.30/t/key_aliases.t 2015-09-28 12:02:27.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/key_aliases.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,13 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 4; +- +-use HTTP::Async; +- +-foreach my $number ( 0, 3 ) { +- my $q2 = HTTP::Async->new( max_redirects => $number ); +- ok $q2, "created object"; +- is $q2->max_redirect, $number, "got $number"; +-} +diff -Nur HTTP-Async-0.30/t/local-addr.t HTTP-Async-0.30_mod/t/local-addr.t +--- HTTP-Async-0.30/t/local-addr.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/local-addr.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,38 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +-use HTTP::Request; +-use Net::EmptyPort; +- +-unless(eval("require Sys::HostIP;") && !$@) { +- plan skip_all => "test requires Sys::HostIP to be installed"; +- exit; +-} +- +-my $ips = Sys::HostIP->new->ips || []; +- +-plan tests => 1 + 2*@$ips; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +- +-for my $ip (@$ips) { +- my $q = HTTP::Async->new; +- +- my $req = HTTP::Request->new( 'GET', "$url_root?delay=0" ); +- +- my %opts = ( +- local_addr => $ip, +- local_port => Net::EmptyPort::empty_port(), +- ); +- ok $q->add_with_opts($req, \%opts), "Added request to the queue with local_addr ($ip) set"; +-# note `lsof -p $$`; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- is $res->code, 200, "Got a response"; +-} +diff -Nur HTTP-Async-0.30/t/make-url-absolute.t HTTP-Async-0.30_mod/t/make-url-absolute.t +--- HTTP-Async-0.30/t/make-url-absolute.t 2013-03-28 13:33:43.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/make-url-absolute.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,24 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 4; +- +-use HTTP::Async; +-use URI; +- +-my $full_url = URI->new('http://www.test.com:8080/foo/bar?baz=bundy'); +- +-my @tests = ( +- 'http://www.test.com:8080/foo/bar?baz=bundy', '/foo/bar?baz=bundy', +- 'bar?baz=bundy', '?baz=bundy', +-); +- +-foreach my $test (@tests) { +- my $url = HTTP::Async::_make_url_absolute( +- url => $test, +- ref => $full_url, +- ); +- +- is "$url", "$full_url", "$test -> $full_url"; +-} +diff -Nur HTTP-Async-0.30/t/not-modified.t HTTP-Async-0.30_mod/t/not-modified.t +--- HTTP-Async-0.30/t/not-modified.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/not-modified.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,26 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 4; +-use HTTP::Request; +-use HTTP::Async; +- +-require 't/TestServer.pm'; +- +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-my $q = HTTP::Async->new; +- +-{ +- my $url = "$url_root/?not_modified=1"; +- +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue"; +- my $res = $q->wait_for_next_response; +- +- is $res->code, 304, "304 Not modified"; +- ok !$res->previous, "does not have a previous reponse"; +-} +- +-1; +diff -Nur HTTP-Async-0.30/t/peer-addr.t HTTP-Async-0.30_mod/t/peer-addr.t +--- HTTP-Async-0.30/t/peer-addr.t 2015-06-02 02:27:03.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/peer-addr.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,30 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +-use HTTP::Request; +- +-plan tests => 4; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-$url_root =~ s/localhost/example.org/; +- +-use HTTP::Async; +- +-my $q = HTTP::Async->new; +- +-my $req = HTTP::Request->new( 'GET', "$url_root?delay=0" ); +- +-my %opts = ( +- peer_addr => 'localhost', +-); +-ok $q->add_with_opts($req, \%opts), "Added request to $url_root to the queue with peer_addr set to 'localhost'"; +- +-$q->poke while !$q->to_return_count; +- +-my $res = $q->next_response; +-is $res->code, 200, "Got a response"; +-like $res->content, qr/Delayed for/, "Got expected response"; +diff -Nur HTTP-Async-0.30/t/pod-coverage.t HTTP-Async-0.30_mod/t/pod-coverage.t +--- HTTP-Async-0.30/t/pod-coverage.t 2013-03-28 13:33:43.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/pod-coverage.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,14 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +- +-eval "use Test::Pod::Coverage 1.00;"; +-plan skip_all => "Test::Pod::Coverage > 1.00 required" if $@; +- +-if ( $] >= 5.009 ) { +- eval "use Pod::Coverage 0.19;"; +- plan skip_all => "Pod::Coverage >= 0.19 required for perls >= 5.9" if $@; +-} +- +-all_pod_coverage_ok(); +diff -Nur HTTP-Async-0.30/t/pod.t HTTP-Async-0.30_mod/t/pod.t +--- HTTP-Async-0.30/t/pod.t 2013-03-28 13:33:43.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/pod.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,7 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +-eval "use Test::Pod 1.00"; +-plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; +-all_pod_files_ok(); +diff -Nur HTTP-Async-0.30/t/polite.t HTTP-Async-0.30_mod/t/polite.t +--- HTTP-Async-0.30/t/polite.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/polite.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,87 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 14; +-use HTTP::Request; +-use Data::Dumper; +- +-use HTTP::Async::Polite; +-my $q = HTTP::Async::Polite->new; +- +-# Check that we can set and get the interval. +-is $q->send_interval, 5, "default interval is 5 seconds"; +-ok $q->send_interval(3), "change interval to 3 seconds"; +-is $q->send_interval, 3, "new interval is 3 seconds"; +- +-require 't/TestServer.pm'; +- +-my @servers = map { TestServer->new() } 1 .. 2; +-my @url_roots = (); +- +-foreach my $s (@servers) { +- push @url_roots, $s->started_ok("starting a test server"); +-} +- +-# Fire off three requests to two different servers. Check that the correct +-# interval is observed between each request and that the two different servers +-# were scaped in parallel. Also add another request so that the lists are not +-# balanced. +-my @urls = +- map { +- my $url_root = $_; +- my ($port) = $url_root =~ m/\d+$/g; +- my $number = $_ eq $url_roots[0] ? 3 : 4; +- my @ret = map { "$url_root/?set_time=$port-$_" } 1 .. $number; +- @ret; +- } @url_roots; +- +-my @requests = map { HTTP::Request->new( GET => $_ ) } @urls; +-ok $q->add(@requests), "Add the requests"; +- +-is $q->to_send_count, 5, "Got correct to_send count"; +-is $q->total_count, 7, "Got correct total count"; +- +-# Get all the responses. +-my @responses = (); +-while ( my $res = $q->wait_for_next_response ) { +- push @responses, $res; +-} +- +-is scalar(@responses), 7, "got six responses back"; +- +-# Extract the url and the timestamp from the responses; +-my %data = (); +-foreach my $res (@responses) { +- my ( $id, $timestamp ) = split /\n/, $res->content, 2; +- my ( $port, $number ) = split /-/, $id, 2; +- +- # Skip if the number is greater than 3 - extra req to test unbalanced list +- next if $number > 3; +- +- s/\s+//g for $port, $number, $timestamp; +- $data{$port}{$number} = $timestamp; +-} +- +-# diag Dumper \%data; +- +-# Check that the requests did not come too close together. +-my @first_times = (); +-foreach my $port ( sort keys %data ) { +- +- my @times = sort { $a <=> $b } values %{ $data{$port} }; +- +- my $last_time = shift @times; +- push @first_times, $last_time; +- +- foreach my $time (@times) { +- +- cmp_ok $time - $last_time, ">", 3, +- "at least three seconds between requests to same domain"; +- +- $last_time = $time; +- } +-} +- +-# check that the first two requests were near each other. +-cmp_ok abs( $first_times[0] - $first_times[1] ), "<", 1, +- "at most 1 second between first two requests"; +diff -Nur HTTP-Async-0.30/t/poll-interval.t HTTP-Async-0.30_mod/t/poll-interval.t +--- HTTP-Async-0.30/t/poll-interval.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/poll-interval.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,85 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 24; +-use HTTP::Request; +-use Time::HiRes 'time'; +- +-BEGIN { +- require 't/test-utils.pl'; +-} +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-# Send off a long request - check that next_response returns at once +-# but that wait_for_next_response returns only when the response has arrived. +- +-# Check that the poll interval is at a sensible default. +-is $q->poll_interval, 0.05, "\$q->poll_interval == 0.05"; +- +-# Check that the poll interval is changeable. +-is $q->poll_interval(0.1), 0.1, "set poll_interval to 0.1"; +-is $q->poll_interval, 0.1, "\$q->poll_interval == 0.1"; +- +-{ +- +- # Get the time since the request was made. +- reset_timer(); +- +- my $url = "$url_root?delay=3"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue - $url"; +- +- # Does next_response return immediately +- ok !$q->next_response, "next_response returns at once"; +- delay_lt_ok 0.4, "Returned quickly (less than 0.4 secs)"; +- +- ok !$q->wait_for_next_response(0), +- "wait_for_next_response(0) returns at once"; +- delay_lt_ok 0.4, "Returned quickly (less than 0.4 secs)"; +- +- ok !$q->wait_for_next_response(1), +- "wait_for_next_response(1) returns after 1 sec without a response"; +- +- delay_ge_ok 1, "Returned after 1 sec delay"; +- delay_lt_ok 1.4, "Returned before 1.4 sec delay"; +- +- my $response = $q->wait_for_next_response(); +- ok $response, "wait_for_next_response got the response"; +- delay_gt_ok 3, "Returned after 3 sec delay"; +- +- is $response->code, 200, "good response (200)"; +- ok $response->is_success, "is a success"; +-} +- +-{ +- reset_timer(); +- +- my $url = "$url_root?delay=1"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue - $url"; +- +- my $response = $q->wait_for_next_response; +- +- ok $response, "wait_for_next_response got the response"; +- +- delay_gt_ok 1, "Returned after 1 sec delay"; +- delay_lt_ok 2, "Returned before 2 sec delay"; +- +- is $response->code, 200, "good response (200)"; +- ok $response->is_success, "is a success"; +-} +- +-{ # Check that wait_for_next_response does not hang if there is nothing +- # to wait for. +- reset_timer(); +- ok !$q->wait_for_next_response, "Did not get a response"; +- delay_lt_ok 1, "Returned in less than 1 sec"; +-} +- +diff -Nur HTTP-Async-0.30/t/proxy.t HTTP-Async-0.30_mod/t/proxy.t +--- HTTP-Async-0.30/t/proxy.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/proxy.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,52 +0,0 @@ +- +-use strict; +-use warnings; +-use URI::Escape; +- +-use Test::More tests => 16; +-use HTTP::Request; +- +-require 't/TestServer.pm'; +-my $s1 = TestServer->new(); +-my $s1_url_root = $s1->started_ok("starting a test server"); +- +-my $s2 = TestServer->new(); +-$s2->{is_proxy} = 1; +-my $s2_url_root = $s2->started_ok("starting a test server"); +- +-ok( $_, "got $_" ) for $s1_url_root, $s2_url_root; +- +-my %tests = ( +- "$s1_url_root/foo/bar?redirect=2" => 200, +- "$s1_url_root/foo/bar?delay=1" => 200, +-); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-foreach my $via_proxy ( 0, 1 ) { +- +- while ( my ( $url, $code ) = each %tests ) { +- +- my $req = HTTP::Request->new( 'GET', $url ); +- +- my %opts = ( proxy_host => '127.0.0.1', proxy_port => $s2->port, ); +- +- my $id = +- $via_proxy +- ? $q->add_with_opts( $req, \%opts ) +- : $q->add($req); +- +- ok $id, "Added request to the queue - $url"; +- +- my $res = $q->wait_for_next_response; +- is( $res->code, $code, "Got a '$code' response" ) +- || diag $res->as_string; +- +- # check that the proxy header was found if this was a proxy request. +- my $proxy_header = $res->header('WasProxied') || ''; +- my $expected = $via_proxy ? 'yes' : ''; +- is($proxy_header, $expected, "check for proxy header '$expected'") +- || diag $res->as_string; +- } +-} +diff -Nur HTTP-Async-0.30/t/proxy-with-https.t HTTP-Async-0.30_mod/t/proxy-with-https.t +--- HTTP-Async-0.30/t/proxy-with-https.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/proxy-with-https.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,52 +0,0 @@ +-use strict; +-use warnings; +-use URI::Escape; +- +-use Test::More; +- +-plan skip_all => "enable these tests by setting REAL_SERVERS" +- unless $ENV{REAL_SERVERS}; +- +-use HTTP::Request; +- +-require 't/TestServer.pm'; +- +-eval "require LWP::Protocol::https"; +-if ($@) { +- plan skip_all => "LWP::Protocol::https required"; +- exit 0; +-} +- +-plan tests => 5; +- +-my $s1 = TestServer->new(); +-$s1->{is_proxy} = 1; +-my $s1_url_root = $s1->started_ok("starting a test server"); +- +-ok( $s1_url_root, "got $s1_url_root" ); +- +-my %tests = ( +- "https://www.google.co.uk/images/srpr/logo4w.png" => 200, +-); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-while ( my ( $url, $code ) = each %tests ) { +- +- my $req = HTTP::Request->new( 'GET', $url ); +- +- my %opts = ( proxy_host => '127.0.0.1', proxy_port => $s1->port, ); +- +- my $id = $q->add_with_opts( $req, \%opts ); +- +- ok $id, "Added request to the queue - $url"; +- +- my $res = $q->wait_for_next_response; +- is( $res->code, $code, "Got a '$code' response" ) +- || diag $res->as_string; +- +- # check that the proxy header was found if this was a proxy request. +- my $proxy_header = $res->header('WasProxied') || ''; +- is $proxy_header, 'yes', "check for proxy header 'yes'"; +-} +diff -Nur HTTP-Async-0.30/t/real-servers.t HTTP-Async-0.30_mod/t/real-servers.t +--- HTTP-Async-0.30/t/real-servers.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/real-servers.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,64 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +- +-plan skip_all => "enable these tests by setting REAL_SERVERS" +- unless $ENV{REAL_SERVERS}; +- +-use HTTP::Request; +-use Time::HiRes 'usleep'; +- +-my $https_ok; +-eval "use Net::HTTPS::NB"; +-if ($@) { +- note "Install Net::HTTPS::NB to test https"; +-} +-else { +- $https_ok = 1; +-} +- +-# Create requests for a few well known sites. +-my @requests = +- map { HTTP::Request->new( GET => $_ ) } +- grep { $https_ok || $_ !~ m{^https://} } +- sort qw( http://www.google.com http://www.yahoo.com https://www.google.com ); +- +-my $tests_per_request = 4; +-plan tests => 3 + $tests_per_request * scalar @requests; +- +-use_ok 'HTTP::Async'; +- +-my $q = HTTP::Async->new(ssl_options => { SSL_verify_mode => 0 }); +-isa_ok $q, 'HTTP::Async'; +- +-# Put all of these onto the queue. +-ok( $q->add($_), "Added request for " . $_->uri ) for @requests; +- +-# Process the queue until they all complete. +-my @responses = (); +- +-while ( $q->not_empty ) { +- +- my $res = $q->next_response; +- my $uri; +- if ($res) { +- $uri = $res->request->uri; +- pass "Got the response from $uri"; +- push @responses, $res; +- } +- else { +- usleep( 1_000_000 * 0.1 ); # 0.1 seconds +- next; +- } +- +- ok $res->is_success, "is success for $uri" +- or diag $res->status_line; +-} +- +-# Check that we got the number needed and that all the responses are +-# HTTP::Response objects. +-is scalar @responses, scalar @requests, "Got the expected number of responses"; +-isa_ok( $_, 'HTTP::Response', "Got a HTTP::Response object" ) for @responses; +- +-# print $_->content for @responses; +diff -Nur HTTP-Async-0.30/t/redirects.t HTTP-Async-0.30_mod/t/redirects.t +--- HTTP-Async-0.30/t/redirects.t 2015-09-28 12:02:27.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/redirects.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,105 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More; +-use HTTP::Request; +- +-my $tests = 21; +-if ($ENV{'REAL_SERVERS'}) { +- $tests += 4; +-} +-plan tests => $tests; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-# Check that the max_redirect is at a sensible level. +-is $q->max_redirect, 7, "max_redirect == 7"; +- +-# Send a request to somewhere that will redirect a certain number of +-# times: +-# +-# ?redirect=$num - if $num is > 0 then it redirects to $num - 1; +- +-{ # Check that a couple of redirects work. +- my $url = "$url_root/foo/bar?redirect=3"; +- +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue"; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- is $res->code, 200, "No longer a redirect"; +- ok $res->previous, "Has a previous reponse"; +- is $res->previous->code, 302, "previous request was a redirect"; +-} +- +-{ # check that 20 redirects stop after the expected number. +- my $url = "$url_root?redirect=20"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue"; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- is $res->code, 302, "Still a redirect"; +- ok $res->previous, "Has a previous reponse"; +- is $res->previous->code, 302, "previous request was a redirect"; +- is $res->request->uri->as_string, "$url_root?redirect=13", +- "last request url correct"; +-} +- +-{ # Set the max_redirect higher and try again. +- +- ok $q->max_redirect(30), "Set the max_redirect higher."; +- +- my $url = "$url_root?redirect=20"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue"; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- is $res->code, 200, "No longer a redirect"; +- ok $res->previous, "Has a previous reponse"; +- is $res->previous->code, 302, "previous request was a redirect"; +-} +- +-{ # Set the max_redirect to zero and check that none happen. +- +- is $q->max_redirect(0), 0, "Set the max_redirect to zero."; +- is $q->max_redirect, 0, "max_redirect is set to zero."; +- +- my $url = "$url_root?redirect=20"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue"; +- $q->poke while !$q->to_return_count; +- +- my $res = $q->next_response; +- is $res->code, 302, "No longer a redirect"; +- ok !$res->previous, "Have no previous reponse"; +-} +- +-if ($ENV{'REAL_SERVERS'}) { +- # Check that redirects have their headers repeated +- # Exmaple from kloevschall (https://github.com/evdb/HTTP-Async/issues/8) +- +- is $q->max_redirect(1), 1, "Set the max_redirect to one."; +- is $q->max_redirect, 1, "max_redirect is set to one."; +- +- my $headers = HTTP::Headers->new(Accept => 'application/x-research-info-systems'); +- +- my $error = $q->add(HTTP::Request->new(GET => 'http://dx.doi.org/10.1126/science.169.3946.635', $headers)); +- my $ok = $q->add(HTTP::Request->new(GET => 'http://data.crossref.org/10.1126%2Fscience.169.3946.635', $headers)); +- +- while (my ($response, $req_id) = $q->wait_for_next_response) { +- ok $response->is_success, sprintf("Got good response (%s, %s) for %s", +- $response->code, +- $response->message, +- $response->base +- ); +- } +-} +diff -Nur HTTP-Async-0.30/t/release-cpan-changes.t HTTP-Async-0.30_mod/t/release-cpan-changes.t +--- HTTP-Async-0.30/t/release-cpan-changes.t 2013-07-18 04:44:00.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/release-cpan-changes.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,14 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More 0.96; +- +-eval "use Test::CPAN::Changes"; +-if ($@) { +- plan skip_all => +- "install Test::CPAN::Changes to run this test"; +-} +- +-changes_file_ok('Changes'); +- +-done_testing(); +diff -Nur HTTP-Async-0.30/t/remove.t HTTP-Async-0.30_mod/t/remove.t +--- HTTP-Async-0.30/t/remove.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/remove.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,105 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More tests => 21; +- +-use Data::Dumper; +- +-use HTTP::Request; +-use HTTP::Async; +- +-## Set up - create an Async object with ten items in its queue +- +-require 't/TestServer.pm'; +-# To ensure that remove and remove_all work on all three states, we need to +-# have items in all three states when we call them. +-# +-# The three states are: to_send, in_progress, and to_return. +-# +-# We can create them by adding items which will run quickly, items which will +-# trickle data slowly, and items which are not running. +-# +-# XXX we currently only test in_progress and to_return as items are hard to +-# keep in the to_send queue, HTTP::Async is too good at moving them into the +-# to_progress queue! +-{ +- my $s = TestServer->new(); +- my $url_root = $s->started_ok("starting a test server"); +- +- my $q = HTTP::Async->new; +- +- is $q->total_count, 0, "total_count starts at zero"; +- +- my %type_to_id = populate_queues($q, $url_root); +- +- ## Remove - test remove() to remove a single item +- +- for my $type (sort keys %type_to_id) { +- my $id = $type_to_id{$type}; +- ok $q->remove($id), "removed '$type' item with id '$id'"; +- } +- +- ok !$q->remove(123456), "removal of bad id '123456' returns false"; +- +- is $q->total_count, 0, "total_count is now zero"; +-} +- +-{ +- my $s = TestServer->new(); +- my $url_root = $s->started_ok("starting a test server"); +- +- my $q = HTTP::Async->new; +- +- is $q->total_count, 0, "total_count starts at zero"; +- +- my %type_to_id = populate_queues($q, $url_root); +- +- ## Remove All - test remove_all() removes all queued items +- +- ok $q->remove_all, "removed all items"; +- +- ok !$q->remove_all, "remove_all() on empty queue returns false"; +- +- is $q->total_count, 0, "total_count is now zero"; +-} +- +-############################################################################## +- +-sub populate_queues { +- my $q = shift; +- my $url_root = shift; +- +- my %type_to_id; +- +- # fast / to_return +- { +- my $url = "$url_root?trickle=1"; +- my $req = HTTP::Request->new('GET', $url); +- ok $type_to_id{'fast'} = $q->add($req), "added fast / to_return item"; +- +- for (1 .. 10) { +- $q->poke; +- last if $q->to_return_count; +- sleep 1; +- } +- +- if (!$q->to_return_count) { +- diag Dumper $q; +- } +- +- is $q->to_return_count, 1, "to_return_count is one"; +- } +- +- # slow / in_progress +- { +- my $url = "$url_root?trickle=1000"; +- my $req = HTTP::Request->new('GET', $url); +- ok $type_to_id{'slow'} = $q->add($req), "added slow / in_progress item"; +- $q->poke; +- is $q->in_progress_count, 1, "in_progress_count is one"; +- } +- +- is $q->total_count, 2, "total_count is now two"; +- +- return %type_to_id; +-} +diff -Nur HTTP-Async-0.30/t/setup.t HTTP-Async-0.30_mod/t/setup.t +--- HTTP-Async-0.30/t/setup.t 2015-09-28 12:02:27.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/setup.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,21 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 16; +- +-use HTTP::Async; +-use HTTP::Async::Polite; +- +-foreach my $class ( 'HTTP::Async', 'HTTP::Async::Polite' ) { +- foreach my $number ( 0, 3 ) { +- +- my $q1 = $class->new; +- is $q1->max_redirect($number), $number, "set to $number"; +- is $q1->max_redirect, $number, "got $number"; +- +- my $q2 = $class->new( max_redirect => $number ); +- ok $q2, "created object"; +- is $q2->max_redirect, $number, "got $number"; +- } +-} +diff -Nur HTTP-Async-0.30/t/strip-host-from-uri.t HTTP-Async-0.30_mod/t/strip-host-from-uri.t +--- HTTP-Async-0.30/t/strip-host-from-uri.t 2013-07-18 04:41:46.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/strip-host-from-uri.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,28 +0,0 @@ +-use strict; +-use warnings; +- +-use Test::More; +-use HTTP::Async; +-use URI; +- +-my %tests = ( +-'http://www.w3.org:8080/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2' +- => '/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2', +- +- 'http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2' => +- '/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2', +- +- 'https://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2' => +- '/Protocols/rfc2616/rfc2616-sec5.html?foo=bar#sec5.1.2', +- +- 'https://www.w3.org:80/Protocols' => '/Protocols', +- +- 'http://localhost:8080?delay=3' => '/?delay=3' +-); +- +-plan tests => scalar keys %tests; +- +-while ( my ( $in, $expected ) = each %tests ) { +- my $out = HTTP::Async::_strip_host_from_uri( URI->new($in) ); +- is $out, $expected, "correctly stripped $in to $out"; +-} +diff -Nur HTTP-Async-0.30/t/template.t HTTP-Async-0.30_mod/t/template.t +--- HTTP-Async-0.30/t/template.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/template.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,20 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More skip_all => 'just a template to base other tests on'; +- +-use Test::More tests => 5; +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-require 't/TestServer.pm'; +- +-# my $s = TestServer->new; +-# my $url_root = $s->started_ok("starting a test server"); +- +-my @servers = map { TestServer->new() } 1 .. 4; +-foreach my $s (@servers) { +- my $url_root = $s->started_ok("starting a test server"); +-} +diff -Nur HTTP-Async-0.30/t/TestServer.pm HTTP-Async-0.30_mod/t/TestServer.pm +--- HTTP-Async-0.30/t/TestServer.pm 2015-06-02 02:27:03.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/TestServer.pm 1969-12-31 19:00:00.000000000 -0500 +@@ -1,203 +0,0 @@ +-use strict; +-use warnings; +- +-# Provide a simple server that can be used to test the various bits. +-package TestServer; +-use base qw/Test::HTTP::Server::Simple HTTP::Server::Simple::CGI/; +- +-use Time::HiRes qw(sleep time); +-use Data::Dumper; +-use Test::More; +-use LWP::UserAgent; +-use Net::EmptyPort (); +- +-sub new { +- my ($class, $port) = @_; +- +- if (!$port) { +- $port = Net::EmptyPort::empty_port(); +- } +- +- # Require a port parameter to be passed in. +- # Any default here would mean the tests don't run properly in parallel. +- if (!$port) { +- die "Missing positional parameter 'port' required"; +- } +- +- return $class->SUPER::new($port); +-} +- +-sub handle_request { +- my ( $self, $cgi ) = @_; +- my $params = $cgi->Vars; +- +- # If we should act as a proxy then the handle_request() behaviour is +- # handled by act_as_proxy. +- return act_as_proxy(@_) if $self->{is_proxy}; +- +- # We should act as a final destination server and so expect an absolute URL. +- my $request_uri = $ENV{REQUEST_URI}; +- if ( $request_uri !~ m!^/! ) { +- warn "ERROR - not absolute request_uri '$request_uri'"; +- return; +- } +- +- # Flush the output so that it goes straight away. Needed for the timeout +- # trickle tests. +- $self->stdout_handle->autoflush(1); +- +- # Do the right thing depending on what is asked of us. +- if ( exists $params->{redirect} ) { +- my $num = $params->{redirect} || 0; +- $num--; +- +- if ( $num > 0 ) { +- print $cgi->redirect( -uri => "?redirect=$num", -nph => 1, ); +- print "You are being redirected..."; +- } +- else { +- print $cgi->header( -nph => 1 ); +- print "No longer redirecting"; +- } +- } +- +- elsif ( exists $params->{delay} ) { +- sleep( $params->{delay} ); +- print $cgi->header( -nph => 1 ); +- print "Delayed for '$params->{delay}'.\n"; +- } +- +- elsif ( exists $params->{trickle} ) { +- +- print $cgi->header( -nph => 1 ); +- +- my $trickle_for = $params->{trickle}; +- my $finish_at = time + $trickle_for; +- +- local $| = 1; +- +- while ( time <= $finish_at ) { +- print time . " trickle $$\n"; +- sleep 0.1; +- } +- +- print "Trickled for '$trickle_for'.\n"; +- } +- +- elsif ( exists $params->{cookie} ) { +- print $cgi->header( +- -nph => 1, +- -cookie => $cgi->cookie(-name => "x", value => "test"), +- ); +- +- print "Sent test cookie\n"; +- } +- +- elsif ( exists $params->{bad_header} ) { +- my $headers = $cgi->header( -nph => 1, ); +- +- # trim trailing whitspace to single newline. +- $headers =~ s{ \s* \z }{\n}xms; +- +- # Add a bad header: +- $headers .= "Bad header: BANG!\n"; +- +- print $headers . "\n\n"; +- print "Produced some bad headers."; +- } +- +- elsif ( my $when = $params->{break_connection} ) { +- +- for (1) { +- last if $when eq 'before_headers'; +- print $cgi->header( -nph => 1 ); +- +- last if $when eq 'before_content'; +- print "content\n"; +- } +- } +- +- elsif ( my $id = $params->{set_time} ) { +- my $now = time; +- print $cgi->header( -nph => 1 ); +- print "$id\n$now\n"; +- } +- +- elsif ( exists $params->{not_modified} ) { +- my $last_modified = HTTP::Date::time2str( time - 60 * 60 * 24 ); +- print $cgi->header( +- -status => '304', +- -nph => 1, +- 'Last-Modified' => $last_modified, +- ); +- print "content\n"; +- } +- +- else { +- warn "DON'T KNOW WHAT TO DO: " . Dumper $params; +- } +- +- # warn "STOP REQUEST - " . time; +- +-} +- +-sub act_as_proxy { +- my ( $self, $cgi ) = @_; +- +- my $request_uri = $ENV{REQUEST_URI}; +- +- # According to the RFC the request_uri must be fully qualified if the +- # request is to a proxy and absolute if it is to a destination server. CHeck +- # that this is the case. +- # +- # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2 +- if ( $request_uri !~ m!^https?://! ) { +- warn "ERROR - not fully qualified request_uri '$request_uri'"; +- return; +- } +- +- my $response = LWP::UserAgent->new( max_redirect => 0 )->get($request_uri); +- +- # Add a header so that we know that this was proxied. +- $response->header( WasProxied => 'yes' ); +- +- print $response->as_string; +- return 1; +-} +- +-# To allow act_as_proxy to work with HTTP::Server::Simple::CGI versions above +-# 0.41_1, where better support for RFC1616 was added, we have to override the +-# parse_request() method to match the pre-0.45_1 version of the method. Lame +-# and hacky but it works. +-sub parse_request { +- my $self = shift; +- my $chunk; +- while ( sysread( STDIN, my $buff, 1 ) ) { +- last if $buff eq "\n"; +- $chunk .= $buff; +- } +- defined($chunk) or return undef; +- $_ = $chunk; +- +- m/^(\w+)\s+(\S+)(?:\s+(\S+))?\r?$/; +- my $method = $1 || ''; +- my $uri = $2 || ''; +- my $protocol = $3 || ''; +- +- return ( $method, $uri, $protocol ); +-} +- +-# Change print() to note() in HTTP::Server::Simple::print_banner +-sub print_banner { +- my $self = shift; +- +- note( +- ref($self) +- . ": You can connect to your server at " +- . "http://localhost:" +- . $self->port +- . "/" +- ); +-} +- +-1; +diff -Nur HTTP-Async-0.30/t/test-utils.pl HTTP-Async-0.30_mod/t/test-utils.pl +--- HTTP-Async-0.30/t/test-utils.pl 2013-07-18 04:41:46.000000000 -0400 ++++ HTTP-Async-0.30_mod/t/test-utils.pl 1969-12-31 19:00:00.000000000 -0500 +@@ -1,26 +0,0 @@ +-use strict; +-use warnings; +- +-use Time::HiRes qw(time); +- +-{ +- my $start_time = undef; +- +- sub reset_timer { return $start_time = time; } +- +- sub delay_lt_ok ($$) { return delay_ok( '<', @_ ); } +- sub delay_le_ok ($$) { return delay_ok( '<=', @_ ); } +- sub delay_ge_ok ($$) { return delay_ok( '>=', @_ ); } +- sub delay_gt_ok ($$) { return delay_ok( '>', @_ ); } +- +- sub delay_ok ($$$) { +- my ( $cmp, $delay, $message ) = @_; +- +- my $timer = time - $start_time; +- +- my $display_test = sprintf '%.2f %s %.2f', $timer, $cmp, $delay; +- return cmp_ok $timer, $cmp, $delay, "$message ($display_test)"; +- } +-} +- +-1; +diff -Nur HTTP-Async-0.30/t/timeout.t HTTP-Async-0.30_mod/t/timeout.t +--- HTTP-Async-0.30/t/timeout.t 2014-11-17 10:59:35.000000000 -0500 ++++ HTTP-Async-0.30_mod/t/timeout.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,67 +0,0 @@ +- +-use strict; +-use warnings; +- +-use Test::More tests => 20; +-use HTTP::Request; +- +-require 't/TestServer.pm'; +-my $s = TestServer->new(); +-my $url_root = $s->started_ok("starting a test server"); +- +-use HTTP::Async; +-my $q = HTTP::Async->new; +- +-# Check that the timeout is at a sensible default. +-is $q->timeout, 180, "\$q->timeout == 180"; +- +-{ # Send a request that should return quickly +- my $url = "$url_root?delay=0"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, 200, "Not timed out (200)"; +-} +- +-is $q->timeout(2), 2, "Set the timeout really low"; +- +-{ # Send a request that should timeout +- my $url = "$url_root?delay=3"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added delayed request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, 504, "timed out (504)"; +- ok $res->is_error, "is an error"; +-} +- +-{ # Send a request that should not timeout as it is trickling back data. +- my $url = "$url_root?trickle=4"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added trickle request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, 200, "response ok (200)"; +- ok !$res->is_error, "is not an error"; +-} +- +-is $q->timeout(1), 1, "Set the timeout really low"; +-is $q->max_request_time(1), 1, "Set the max_request_time really low"; +- +-{ # Send a request that should timeout despite trickling back data. +- my $url = "$url_root?trickle=3"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added trickle request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, 504, "timed out (504)"; +- ok $res->is_error, "is an error"; +-} +- +-is $q->timeout(10), 10, "Lengthen the timeout"; +-is $q->max_request_time(300), 300, "Lengthen the max_request_time"; +- +-{ # Send same request that should now be ok +- my $url = "$url_root?delay=3"; +- my $req = HTTP::Request->new( 'GET', $url ); +- ok $q->add($req), "Added delayed request to the queue - $url"; +- my $res = $q->wait_for_next_response; +- is $res->code, 200, "Not timed out (200)"; +-} diff --git a/perl-HTTP-Async/HTTP-Async-0.30.tar.gz b/perl-HTTP-Async/HTTP-Async-0.30.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0a091cb7c5a3a9f9a163f6837d20feffdb675f42 GIT binary patch literal 24508 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 BXy^a{ literal 0 HcmV?d00001 diff --git a/perl-HTTP-Async/perl-HTTP-Async.spec b/perl-HTTP-Async/perl-HTTP-Async.spec new file mode 100644 index 0000000..e67dfb8 --- /dev/null +++ b/perl-HTTP-Async/perl-HTTP-Async.spec @@ -0,0 +1,143 @@ +%define upstream_name HTTP-Async +%define upstream_version 0.30 + +%{?perl_default_filter} + +Name: perl-%{upstream_name} +Version: %{upstream_version} +Release: 2 + +Summary: Politely process multiple HTTP requests +License: GPL+ or Artistic +Group: Development/Perl +Url: http://search.cpan.org/dist/%{upstream_name} +Source0: http://www.cpan.org/modules/by-module/HTTP/%{upstream_name}-%{upstream_version}.tar.gz +Patch: HTTP-Async-0.30.patch +BuildArch: noarch + +%description +Although using the conventional 'LWP::UserAgent' is fast and easy it does +have some drawbacks - the code execution blocks until the request has been +completed and it is only possible to process one request at a time. +'HTTP::Async' attempts to address these limitations. + +It gives you a 'Async' object that you can add requests to, and then get +the requests off as they finish. The actual sending and receiving of the +requests is abstracted. As soon as you add a request it is transmitted, if +there are too many requests in progress at the moment they are queued. +There is no concept of starting or stopping - it runs continuously. + +Whilst it is waiting to receive data it returns control to the code that +called it meaning that you can carry out processing whilst fetching data +from the network. All without forking or threading - it is actually done +using 'select' lists. + +%prep +%setup -q -n %{upstream_name}-%{upstream_version} + +%patch -p1 + +%build +CFLAGS="$RPM_OPT_FLAGS $CFLAGS" %__perl Makefile.PL + +make + +#%check +#%make test + +%install +make PREFIX=%{_prefix} \ + DESTDIR=%{buildroot} \ + INSTALLDIRS=site \ + install +#%make_install + +find ${RPM_BUILD_ROOT} -type f -name perllocal.pod -exec rm -f {} ';' +find ${RPM_BUILD_ROOT} -type f -name .packlist -exec rm -f {} ';' + +find ${RPM_BUILD_ROOT} \( -path '*/perllocal.pod' -o -path '*/.packlist' -o -path '*.bs' \) -a -prune -o -type f -printf "/%%P\n" > version-filelist +if [ "$(cat version-filelist)X" = "X" ] ; then + echo "ERROR: EMPTY FILE LIST" + exit 1 +fi + + +%files -f version-filelist +%defattr(-,root,root) + +%changelog +* Sat Feb 20 2016 umeabot 0.300.0-2.mga6 ++ Revision: 971324 +- Mageia 6 Mass Rebuild + +* Wed Oct 14 2015 sander85 0.300.0-1.mga6 ++ Revision: 891385 +- update to 0.30 + +* Thu Jun 25 2015 shlomif 0.290.0-1.mga6 ++ Revision: 843206 +- update to 0.29 + +* Sat Oct 18 2014 umeabot 0.260.0-4.mga5 ++ Revision: 788383 +- Rebuild to potentially add missing dependencies + +* Wed Oct 15 2014 umeabot 0.260.0-3.mga5 ++ Revision: 742741 +- Second Mageia 5 Mass Rebuild + +* Tue Sep 16 2014 umeabot 0.260.0-2.mga5 ++ Revision: 684992 +- Mageia 5 Mass Rebuild + +* Sat Jun 07 2014 sander85 0.260.0-1.mga5 ++ Revision: 634333 +- update to 0.26 + +* Tue Mar 25 2014 jquelin 0.250.0-1.mga5 ++ Revision: 608358 +- update to 0.25 + +* Tue Feb 04 2014 shlomif 0.230.0-1.mga5 ++ Revision: 581190 +- New version 0.23 + +* Sat Oct 19 2013 umeabot 0.220.0-2.mga4 ++ Revision: 534493 +- Mageia 4 Mass Rebuild + +* Thu Sep 12 2013 sander85 0.220.0-1.mga4 ++ Revision: 478134 +- update to 0.22 + +* Thu Aug 29 2013 sander85 0.210.0-1.mga4 ++ Revision: 473095 +- update to 0.21 + +* Sun Jul 21 2013 sander85 0.200.0-1.mga4 ++ Revision: 456932 +- update to 0.20 + +* Sun Jun 02 2013 shlomif 0.180.0-1.mga4 ++ Revision: 434433 +- New version 0.18 + +* Sun Jan 13 2013 umeabot 0.110.0-2.mga3 ++ Revision: 368255 +- Mass Rebuild - https://wiki.mageia.org/en/Feature:Mageia3MassRebuild + +* Wed Nov 14 2012 jquelin 0.110.0-1.mga3 ++ Revision: 317678 +- update to 0.11 + +* Mon Jun 04 2012 kharec 0.100.0-1.mga3 ++ Revision: 253983 +- update to 0.10 + +* Fri Dec 16 2011 kharec 0.90.0-1.mga2 ++ Revision: 182446 +- imported package perl-HTTP-Async + + +* Fri Dec 16 2011 cpan2dist 0.09-1mga +- initial mageia release, generated with cpan2dist diff --git a/perl-Net-HTTPS-NB/Build-note b/perl-Net-HTTPS-NB/Build-note new file mode 100644 index 0000000..0264810 --- /dev/null +++ b/perl-Net-HTTPS-NB/Build-note @@ -0,0 +1,16 @@ +Build Notes + +1. To build rpm +1) copy Net-HTTPS-NB-0.14.patch and Net-HTTPS-NB-0.14.tar.gz into /root/rpmbuild/SOURCES +2) copy perl-Net-HTTPS-NB.spec into /root/rpmbuild/SPECS +3) rpmbuild -ba /root/rpmbuild/SPECS/perl-Net-HTTPS-NB.spec +4) The rpm package is located at /root/rpmbuild/RPMS/noarch/perl-Net-HTTPS-NB-0.14-2.noarch.rpm + +2. To build .deb package +1) Install 'alien' on the build machine +2) Create a temparary directory such as /tmp/perl-Net-HTTPS-NB, and copy the perl-Net-HTTPS-NB-0.14-2.noarch.rpm package into it +3) Use the command "alien -k --scripts -s perl-Net-HTTPS-NB-0.14-2.noarch.rpm" to generate debian packaging related files. + It will generate a directory like ./perl-Net-HTTPS-NB-0.14 +3) cd perl-Net-HTTPS-NB-0.14; mv usr/local/share/ usr/; rmdir usr/local/ +4) dpkg-buildpackage -uc -us +5) The .deb package perl-net-https-nb_0.14-2_all.deb will be located at /tmp/perl-Net-HTTPS-NB diff --git a/perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.patch b/perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.patch new file mode 100644 index 0000000..a4af451 --- /dev/null +++ b/perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.patch @@ -0,0 +1,197 @@ +diff -Nru Net-HTTPS-NB-0.14/examples/google_multi.pl Net-HTTPS-NB-0.14_mod/examples/google_multi.pl +--- Net-HTTPS-NB-0.14/examples/google_multi.pl 2015-10-14 09:05:46.000000000 -0400 ++++ Net-HTTPS-NB-0.14_mod/examples/google_multi.pl 1969-12-31 19:00:00.000000000 -0500 +@@ -1,112 +0,0 @@ +-#!/usr/bin/env perl +- +-use strict; +-use warnings; +-use AnyEvent; +-use Errno qw/EWOULDBLOCK EAGAIN/; +-use lib '../lib'; +-use Net::HTTPS::NB; +- +-# Get number of the search results for each specified language in parallel via encrypted google +-# Make it easier with AnyEvent +- +-my $loop = AnyEvent->condvar; +-$loop->begin; +- +-for my $q (qw(perl python ruby php lua)) { +- my $sock = Net::HTTPS::NB->new(Host => 'encrypted.google.com', Blocking => 0) +- or next; +- +- $loop->begin(); +- +- my $wc; $wc = AnyEvent->io( +- fh => $sock, +- poll => 'w', # first wait until non-blocking socket connection completed +- cb => sub { wait_connection($wc, $loop, $sock, $q) } +- ); +-} +- +-$loop->end; +-$loop->recv(); +- +-# wait until non-blocking connection completed +-sub wait_connection { +- undef $_[0]; # remove watcher completely +- my ($wc, $loop, $sock, $q) = @_; +- +- if ($sock->connected) { # handshake completed +- print "$q: Connected\n"; +- $sock->write_request(GET => "/search?q=$q"); +- my $wh; $wh = AnyEvent->io( # now wait headers +- fh => $sock, +- poll => 'r', +- cb => sub { wait_headers($wh, $loop, $sock, $q) } +- ); +- } +- elsif($HTTPS_ERROR == HTTPS_WANT_READ) { +- $wc = AnyEvent->io( # handshake need reading +- fh => $sock, +- poll => 'r', +- cb => sub { wait_connection($wc, $loop, $sock, $q) } +- ); +- } +- elsif($HTTPS_ERROR == HTTPS_WANT_WRITE) { +- $wc = AnyEvent->io( # handshake need writing +- fh => $sock, +- poll => 'w', +- cb => sub { wait_connection($wc, $loop, $sock, $q) } +- ); +- } +- else { +- print "$q: Connection failed - $HTTPS_ERROR\n"; +- $loop->end(); +- } +-} +- +-# wait for full headers +-sub wait_headers { +- my (undef, $loop, $sock, $q) = @_; +- +- if (my @h = $sock->read_response_headers()) { +- undef $_[0]; # remove headers watcher +- +- print "$q: HTTP code - $h[0]\n"; +- my $body = ''; +- +- unless (wait_body($_, $loop, $sock, $q, \$body)) { +- my $wb; $wb = AnyEvent->io( # now wait body +- fh => $sock, +- poll => 'r', +- cb => sub { wait_body($wb, $loop, $sock, $q, \$body) } +- ); +- } +- } +- # else this sub will invoked again when new data will arrive +-} +- +-# wait for full body +-sub wait_body { +- my (undef, $loop, $sock, $q, $body) = @_; +- +- my ($n, $buf); +- while (1) { +- $n = $sock->read_entity_body($buf, 1024); +- if ($n > 0) { +- substr($$body, length $$body) = $buf; # append body +- } +- elsif ((defined($n) && $n == 0) || (!defined($n) && $! != EWOULDBLOCK && $! != EAGAIN)) { +- # error or eof, but who cares? +- undef $_[0]; # remove body watcher +- my ($result) = $$body =~ /([\d,]+\s+results?)/; +- print "$q: ", $result||'unknown', "\n"; +- $loop->end; +- return 1; # body readed +- } +- else { +- # wait more data +- last; +- } +- } +- +- 0; # body still not readed +-} +diff -Nru Net-HTTPS-NB-0.14/Makefile.PL Net-HTTPS-NB-0.14_mod/Makefile.PL +--- Net-HTTPS-NB-0.14/Makefile.PL 2015-10-14 07:11:10.000000000 -0400 ++++ Net-HTTPS-NB-0.14_mod/Makefile.PL 2016-03-14 03:09:39.063284216 -0400 +@@ -6,7 +6,7 @@ + NAME => 'Net::HTTPS::NB', + LICENSE => 'perl', + VERSION_FROM => 'lib/Net/HTTPS/NB.pm', # finds $VERSION +- PREREQ_PM => { Exporter => 0, IO::Socket::SSL => 0.98, Net::HTTP => 0, Net::HTTPS => 0, Test::More => 0.88 }, ++ PREREQ_PM => { Exporter => 0, IO::Socket::SSL => 0.98, Net::HTTP => 0, Net::HTTPS => 0 }, + META_MERGE => { resources => {repository => 'https://github.com/olegwtf/p5-Net-HTTPS-NB'} }, + ($] >= 5.005 ? ## Add these new keywords supported since 5.005 + (ABSTRACT_FROM => 'lib/Net/HTTPS/NB.pm', # retrieve abstract from module +diff -Nru Net-HTTPS-NB-0.14/META.json Net-HTTPS-NB-0.14_mod/META.json +--- Net-HTTPS-NB-0.14/META.json 2015-10-14 09:13:45.000000000 -0400 ++++ Net-HTTPS-NB-0.14_mod/META.json 2016-03-14 03:09:59.463284615 -0400 +@@ -36,7 +36,6 @@ + "IO::Socket::SSL" : "0.98", + "Net::HTTP" : "0", + "Net::HTTPS" : "0", +- "Test::More" : "0.88" + } + } + }, +diff -Nru Net-HTTPS-NB-0.14/META.yml Net-HTTPS-NB-0.14_mod/META.yml +--- Net-HTTPS-NB-0.14/META.yml 2015-10-14 09:13:45.000000000 -0400 ++++ Net-HTTPS-NB-0.14_mod/META.yml 2016-03-14 03:10:10.243284924 -0400 +@@ -22,7 +22,6 @@ + IO::Socket::SSL: '0.98' + Net::HTTP: '0' + Net::HTTPS: '0' +- Test::More: '0.88' + resources: + repository: https://github.com/olegwtf/p5-Net-HTTPS-NB + version: 0.14 +diff -Nru Net-HTTPS-NB-0.14/t/Net-HTTPS-NB.t Net-HTTPS-NB-0.14_mod/t/Net-HTTPS-NB.t +--- Net-HTTPS-NB-0.14/t/Net-HTTPS-NB.t 2015-10-14 07:11:10.000000000 -0400 ++++ Net-HTTPS-NB-0.14_mod/t/Net-HTTPS-NB.t 1969-12-31 19:00:00.000000000 -0500 +@@ -1,43 +0,0 @@ +-#!/usr/bin/env perl +- +-use Test::More; +-BEGIN { +- use_ok('Net::HTTPS::NB'); +-} +-use strict; +- +-SKIP: { +- skip "I heared fork doesn't work on Windows" +- if $^O =~ /MSWin/i; +- +- my ($host, $port) = make_server(); +- my $start = time(); +- my $sock = Net::HTTPS::NB->new(Host => $host, PeerPort => $port); +- +- ok(time() - $start >= 3, 'Blocking connect'); +- ok(! defined $sock, 'HTTPS init error'); +- +- ($host, $port) = make_server(); +- $start = time(); +- $sock = Net::HTTPS::NB->new(Host => $host, PeerPort => $port, Blocking => 0); +- +- ok(time() - $start < 3, 'Non blocking connect'); +- is($sock->connected, 0, 'Invalid socket connection'); +- isa_ok($sock, 'Net::HTTPS::NB'); +-} +- +-done_testing(); +- +-sub make_server { +- my $serv = IO::Socket::INET->new(Listen => 3); +- my $child = fork(); +- die 'fork:', $! unless defined $child; +- +- if ($child == 0) { +- sleep 3; +- $serv->accept(); +- exit; +- } +- +- return ($serv->sockhost eq "0.0.0.0" ? "127.0.0.1" : $serv->sockhost, $serv->sockport); +-} diff --git a/perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.tar.gz b/perl-Net-HTTPS-NB/Net-HTTPS-NB-0.14.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..91d45faf25eea5c7a95a318b076a7a521e0b3ecb GIT binary patch literal 5777 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 PY}fw+cq= 0.980.0 +BuildRequires: perl(Net::HTTP) +BuildRequires: perl(Net::HTTPS) +BuildArch: noarch + +%description +Same interface as Net::HTTPS but it will never try multiple reads when the +read_response_headers() or read_entity_body() methods are invoked. In +addition allows non-blocking connect. + +* If read_response_headers() did not see enough data to complete the + headers an empty list is returned. + +* If read_entity_body() did not see new entity data in its read the value + -1 is returned. + +%prep +%setup -q -n %{upstream_name}-%{upstream_version} + +%patch -p1 + +%build +%__perl Makefile.PL + +make + +%install +%make_install +find ${RPM_BUILD_ROOT} -type f -name perllocal.pod -exec rm -f {} ';' +find ${RPM_BUILD_ROOT} -type f -name .packlist -exec rm -f {} ';' +find ${RPM_BUILD_ROOT} \( -path '*/perllocal.pod' -o -path '*/.packlist' -o -path '*.bs' \) -a -prune -o -type f -printf "/%%P\n" > version-filelist +if [ "$(cat version-filelist)X" = "X" ] ; then + echo "ERROR: EMPTY FILE LIST" + exit 1 +fi + +%files -f version-filelist +%defattr(-,root,root) + +%changelog +* Sat Feb 20 2016 umeabot 0.140.0-2.mga6 ++ Revision: 971331 +- Mageia 6 Mass Rebuild + + + sander85 + - update to 0.14 + +* Wed Oct 14 2015 sander85 0.140.0-1.mga6 ++ Revision: 891476 +- update to 0.14 + +* Sun Oct 19 2014 umeabot 0.130.0-5.mga5 ++ Revision: 788555 +- Rebuild to potentially add missing dependencies + +* Wed Oct 15 2014 umeabot 0.130.0-4.mga5 ++ Revision: 749262 +- Second Mageia 5 Mass Rebuild + +* Tue Sep 16 2014 umeabot 0.130.0-3.mga5 ++ Revision: 685663 +- Mageia 5 Mass Rebuild + +* Sat Oct 19 2013 umeabot 0.130.0-2.mga4 ++ Revision: 527941 +- Mageia 4 Mass Rebuild + +* Fri Jun 14 2013 kharec 0.130.0-1.mga4 ++ Revision: 442978 +- update to 0.13 + +* Fri Feb 22 2013 kharec 0.120.0-1.mga3 ++ Revision: 399852 +- imported package perl-Net-HTTPS-NB + + +* Fri Feb 22 2013 cpan2dist 0.12-1mga +- initial mageia release, generated with cpan2dist