view release on metacpan or search on metacpan
my $self = shift;
return unless $self->{sid};
# Send a post request as defined in
# http://www.avm.de/de/Extern/files/session_id/AVM_Technical_Note_-_Session_ID.pdf
my $req = HTTP::Request->new(POST => $self->{login_url});
$req->content_type("application/x-www-form-urlencoded");
my $login = "sid=".$self->{sid}."&security:command/logout=fcn";
$req->content($login);
my $resp = $self->{ua}->request($req);
die "Cannot logout SID ",$self->{sid},": ",$resp->status_line unless $resp->is_success;
my $input = $challenge . '-' . $self->{password};
Encode::from_to($input, 'ascii', 'utf16le');
my $challengeresponse = $challenge . '-' . lc(Digest::MD5::md5_hex($input));
# Send the challenge back with encoded password
my $req = HTTP::Request->new(POST => $self->{login_url});
$req->content_type("application/x-www-form-urlencoded");
my $login = "response=$challengeresponse";
if ($self->{user}) {
$login .= "&username=" . $self->{user};
}
view release on metacpan or search on metacpan
bin/remote.pl view on Meta::CPAN
# fetch the content
my @items;
my @srcs = $class->sources($_[1]);
my $ua = LWP::UserAgent->new( env_proxy => 1 );
foreach my $src (@srcs) {
my $res = $ua->request( HTTP::Request->new( GET => $src ) );
if ( ! $res->is_success() ) {
carp "Failed to get content at $src (" . $res->status_line();
return;
}
view release on metacpan or search on metacpan
lib/API/Assembla.pm view on Meta::CPAN
}
sub make_req {
my ($self, $path) = @_;
my $req = HTTP::Request->new(GET => $self->url.$path);
$req->header(Accept => 'application/xml');
$req->authorization_basic($self->username, $self->password);
return $req;
}
view release on metacpan or search on metacpan
lib/API/CLI.pm view on Meta::CPAN
use base 'App::Spec::Run::Cmd';
use URI;
use YAML::XS ();
use LWP::UserAgent;
use HTTP::Request;
use App::Spec;
use JSON::XS;
use API::CLI::Request;
use Moo;
view release on metacpan or search on metacpan
lib/API/CPanel.pm view on Meta::CPAN
return '' unless ( $query_string && $auth_hash );
warn "Auth hash: $auth_hash\nQuery string: $query_string\n" if $DEBUG;
my $ua = LWP::UserAgent->new;
my $request = HTTP::Request->new( GET => $query_string );
$request->header( Authorization => $auth_hash );
my $response = $ua->request( $request );
my $content = $response->content;
if ($response->header('content-type') eq 'text/xml') {
view release on metacpan or search on metacpan
lib/API/DirectAdmin.pm view on Meta::CPAN
package API::DirectAdmin;
use Modern::Perl '2010';
use LWP::UserAgent;
use HTTP::Request;
use Data::Dumper;
use Carp;
use URI;
our $VERSION = 0.09;
lib/API/DirectAdmin.pm view on Meta::CPAN
confess "URL is empty" unless $url;
my $content;
my $ua = LWP::UserAgent->new;
my $request = HTTP::Request->new( $method, $url );
if ( $method eq 'GET' ) {
my $response = $ua->request( $request );
$content = $response->content;
}
lib/API/DirectAdmin.pm view on Meta::CPAN
=head1 DEPENDENCIES
This module requires these other modules and libraries:
Modern::Perl
LWP::UserAgent
HTTP::Request
URI
Carp
Data::Dumper
=head1 COPYRIGHT AND LICENCE
view release on metacpan or search on metacpan
lib/API/Drip/Request.pm view on Meta::CPAN
use File::Spec;
use File::HomeDir;
use Readonly;
use Carp;
use LWP::UserAgent;
use HTTP::Request::Common;
use JSON;
use URI;
use Data::Printer;
Readonly our %DEFAULTS => (
lib/API/Drip/Request.pm view on Meta::CPAN
my $uri = URI->new($self->{DRIP_URI});
$uri->path_segments( $uri->path_segments, $self->{DRIP_ID}, split( '/', $endpoint) );
$self->{debugger}->( 'Requesting: ' . $uri->as_string );
my $request = HTTP::Request->new( $method => $uri->as_string, );
if ( ref($content) ) {
$request->content_type('application/vnd.api+json');
$request->content( encode_json( $content ) );
}
$request->authorization_basic( $self->{DRIP_TOKEN}, '' );
view release on metacpan or search on metacpan
lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN
#
# Import HTTP::Headers
#
use HTTP::Headers;
#
# Import HTTP::Request
#
use HTTP::Request;
#
# Import LWP::UserAgent
#
use LWP::UserAgent;
#
lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN
$headers->push_header( Content_Type => $type );
}
}
# Create HTTP Request
$request = HTTP::Request->new( $method, $url, $headers, $what );
# Create End Point used to communicate with remote server
$endpoint = LWP::UserAgent->new(
keep_alive => 0,
cookie_jar => {},
lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN
L<API::Eulerian::EDW::Status>
L<HTTP::Headers>
L<HTTP::Request>
L<HTTP::Status>
L<LWP::UserAgent>
view release on metacpan or search on metacpan
lib/API/Handle.pm view on Meta::CPAN
$API::Handle::VERSION = '0.02';
}
use Moose::Role;
use namespace::autoclean;
use HTTP::Request;
use bytes;
use feature ':5.10';
use String::CamelCase qw/camelize decamelize/;
use Tie::Hash::Indexed;
lib/API/Handle.pm view on Meta::CPAN
);
}
sub req {
my ( $self, %args ) = @_;
my $req = new HTTP::Request;
$args{content} ||= $args{data} ||= $args{body};
$args{method} ||= $args{type};
$args{uri} ||= $self->_join_uri( $args{path} );
view release on metacpan or search on metacpan
lib/API/INSEE/Sirene.pm view on Meta::CPAN
use strict;
use warnings;
use Carp 'croak';
use JSON;
use HTTP::Request::Common qw/ GET POST /;
use HTTP::Status ':constants';
use List::Util 'any';
use LWP::UserAgent;
use POSIX 'strftime';
use Switch;
lib/API/INSEE/Sirene.pm view on Meta::CPAN
=item * L<< JSON|https://metacpan.org/pod/JSON >>
=item * L<< List::Util|https://perldoc.perl.org/List::Util >>
=item * L<< HTTP::Request::Common|https://metacpan.org/pod/HTTP::Request::Common >>
=item * L<< HTTP::Status|https://metacpan.org/pod/HTTP::Status >> B<< version < 6.26 >>
=item * L<< LWP::UserAgent|https://metacpan.org/pod/LWP::UserAgent >>
view release on metacpan or search on metacpan
lib/API/Mathpix.pm view on Meta::CPAN
package API::Mathpix;
use Moose;
use JSON::PP;
use LWP::UserAgent;
use HTTP::Request;
use MIME::Base64;
use Algorithm::LeakyBucket;
use API::Mathpix::Response;
lib/API/Mathpix.pm view on Meta::CPAN
':app_key' => $self->app_key,
];
my $encoded_data = encode_json($opt);
my $r = HTTP::Request->new('POST', $url, $headers, $encoded_data);
my $response;
if ($self->_bucket->tick) {
$response = $self->_ua->request($r);
view release on metacpan or search on metacpan
lib/API/Octopart.pm view on Meta::CPAN
if ($self->{ua_debug})
{
$ua->add_handler(
"request_send",
sub {
my $msg = shift; # HTTP::Request
print STDERR "SEND >> \n"
. $msg->headers->as_string . "\n"
. "\n";
return;
}
lib/API/Octopart.pm view on Meta::CPAN
my $response;
my $tries = 0;
while ($tries < 3)
{
$req = HTTP::Request->new('POST' => 'https://octopart.com/api/v4/endpoint',
HTTP::Headers->new(
'Host' => 'octopart.com',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'Accept-Encoding' => 'gzip, deflate',
view release on metacpan or search on metacpan
lib/API/ParallelsWPB.pm view on Meta::CPAN
use strict;
use warnings;
use LWP::UserAgent;
use HTTP::Request;
use JSON::XS;
use Carp;
use API::ParallelsWPB::Response;
use base qw/ API::ParallelsWPB::Requests /;
lib/API/ParallelsWPB.pm view on Meta::CPAN
sub _send_request {
my ( $self, $data, $url, $post_data ) = @_;
my $ua = LWP::UserAgent->new();
my $req = HTTP::Request->new( $data->{req_type} => $url );
if ( $data->{req_type} eq 'POST' || $data->{req_type} eq 'PUT' ) {
$req->header( 'content-type' => 'application/json' );
$req->content( $post_data );
}
view release on metacpan or search on metacpan
lib/API/Plesk.pm view on Meta::CPAN
use warnings;
use Carp;
use Data::Dumper;
use HTTP::Request;
use LWP::UserAgent;
use XML::Fast;
use version;
use API::Plesk::Response;
lib/API/Plesk.pm view on Meta::CPAN
# Send xml request to plesk api
sub xml_http_req {
my ($self, $xml) = @_;
# HTTP::Request undestends only bytes
utf8::encode($xml) if utf8::is_utf8($xml);
my $ua = new LWP::UserAgent( parse_head => 0 );
my $req = new HTTP::Request POST => $self->{url};
if ($self->{secret_key}) {
$req->push_header(':KEY', $self->{secret_key});
} else {
$req->push_header(':HTTP_AUTH_LOGIN', $self->{username});
view release on metacpan or search on metacpan
requires => {
'API::Plesk' => '1.06',
'Data::Dumper' => 0,
'LWP::UserAgent' => 0,
'Getopt::Long' => 0,
'HTTP::Request' => 0,
'Carp' => 0,
'URI' => 0,
},
build_requires => {
'Test::More' => 0,
view release on metacpan or search on metacpan
ReviewBoard.pm view on Meta::CPAN
$self->{_useragent} = LWP::UserAgent->new;
$self->{_cookie_jar} = HTTP::Cookies->new(file => "lwpcookies.txt", autosave => 1);
# post request to login
my $link = $self->{_hostedurl}.'api/json/accounts/login/';
my $request = new HTTP::Request('POST',$link);
my $content = 'username='.$self->{_username}.'&password='.$self->{_password};
$request->content($content);
my $response = $self->{_useragent}->simple_request($request);
ReviewBoard.pm view on Meta::CPAN
);
$self->{_changenum} = $args{changenum};
# get request to get review number based on change number
my $changenumlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $changenumlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml=~ m/.*"id": (\d+),.*/;
ReviewBoard.pm view on Meta::CPAN
$self->{_changenum} = $args{changenum};
# get request to get review number based on change number
my $changenumlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $changenumlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*"description": "(.*)", "links".*/;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $changenumlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $changenumlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*"time_added": "(.*)", "summary".*/;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $changenumlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $changenumlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ /.*"last_updated": "(.*)", "description".*/;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*"target_people": (.*), "testing_done".*/;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_changenum} = $args{changenum};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?changenum='.$self->{_changenum};
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*"bugs_closed": (.*), "changenum".*/;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_reviewnum} = $args{reviewnum};
my $userlink = $self->{_hostedurl}.'/api/review-requests/'.$self->{_reviewnum}.'/reviews/?counts-only=1';
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*{"count": (\d+).*/ ;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_user} = $args{user};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?from-user='.$self->{_user}.'&status=all&counts-only=1';
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*{"count": (\d+).*/ ;
ReviewBoard.pm view on Meta::CPAN
$self->{_user} = $args{user};
$self->{_startdate} = $args{startdate};
$self->{_enddate} = $args{enddate};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?from-user='.$self->{_user}.'&time-added-from='.$self->{_startdate}.'&time-added-to='.$self->{_enddate}.'&status=all&counts-only=1';
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*{"count": (\d+).*/ ;
ReviewBoard.pm view on Meta::CPAN
$self->{_user} = $args{user};
$self->{_status} = $args{status};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?from-user='.$self->{_user}.'&status='.$self->{_status}.'&counts-only=1';
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*{"count": (\d+).*/ ;
ReviewBoard.pm view on Meta::CPAN
}
);
$self->{_user} = $args{user};
my $userlink = $self->{_hostedurl}.'/api/review-requests/?to-users='.$self->{_user}.'&counts-only=1';
my $request = new HTTP::Request('GET', $userlink);
$self->{_cookie_jar}->add_cookie_header($request);
my $response = $self->{_useragent}->simple_request($request);
my $xml = $response->as_string;
$xml =~ m/.*{"count": (\d+).*/ ;
view release on metacpan or search on metacpan
lib/API/Vultr.pm view on Meta::CPAN
my $lc_method = lc $method;
return $self->ua->$lc_method( $uri,
Authorization => 'Bearer ' . $self->{api_key} );
}
else {
my $request = HTTP::Request->new( uc $method, $uri );
$request->header( 'Content-Type' => 'application/json' );
$request->content($body);
return $self->ua->request($request);
}
}
view release on metacpan or search on metacpan
"perl" : "5.014"
}
},
"test" : {
"requires" : {
"HTTP::Request::Common" : "0",
"Path::Class" : "0",
"Test::Class" : "0",
"Test::Deep" : "0",
"Test::Deep::JSON" : "0",
"Test::Fatal" : "0",
view release on metacpan or search on metacpan
},
"test" : {
"requires" : {
"AnyEvent" : "0",
"AnyEvent::Socket" : "0",
"HTTP::Request::Common" : "0",
"Plack::Test" : "0",
"Test::More" : "0.98",
"Test::TCP" : "0"
}
}
view release on metacpan or search on metacpan
lib/APP/REST/RestTestSuite.pm view on Meta::CPAN
use 5.006;
use strict;
use warnings FATAL => 'all';
use Data::Dumper;
use HTTP::Request;
use Time::HiRes qw( time sleep );
use File::Path;
use Cwd;
use LWP::UserAgent;
use APP::REST::ParallelMyUA;
lib/APP/REST/RestTestSuite.pm view on Meta::CPAN
$req_content_type = $tc->{request_content_type};
$req_body = $tc->{request_body} || 0;
$status = $tc->{response_status};
if ( $tc->{request_method} =~ /get/i ) {
$request = HTTP::Request->new( $method, $uri );
$request->authorization_basic( $username, $password )
if ( $username && $password );
} else {
$request =
HTTP::Request->new( $method, $uri, new HTTP::Headers, $req_body );
$request->authorization_basic( $username, $password )
if ( $username && $password );
$request->content_type($req_content_type);
$request->content_length( length($req_body) );
}
lib/APP/REST/RestTestSuite.pm view on Meta::CPAN
$method = uc( $tc->{request_method} );
$req_content_type = $tc->{request_content_type};
$req_body = $tc->{request_body} || 0;
$status = $tc->{response_status};
my $request = HTTP::Request->new( $method, $uri );
$request->authorization_basic( $username, $password )
if ( $username && $password );
push( @reqs, $request );
}
view release on metacpan or search on metacpan
lib/ASNMTAP/Asnmtap/Plugins/WebTransact.pm view on Meta::CPAN
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
use CGI::Carp qw(fatalsToBrowser set_message cluck);
use HTTP::Request::Common qw(GET POST HEAD);
use HTTP::Cookies;
use LWP::Debug;
use LWP::UserAgent;
view release on metacpan or search on metacpan
lib/ASP4/ErrorHandler/Remote.pm view on Meta::CPAN
use strict;
use warnings 'all';
use base 'ASP4::ErrorHandler';
use vars __PACKAGE__->VARS;
use LWP::UserAgent;
use HTTP::Request::Common;
use HTTP::Date 'time2iso';
use JSON::XS;
use Data::Dumper;
require ASP4;
view release on metacpan or search on metacpan
lib/AWS/CloudFront/Request.pm view on Meta::CPAN
package
AWS::CloudFront::Request;
use VSO;
use HTTP::Request;
use AWS::CloudFront::ResponseParser;
has 'cf' => (
is => 'ro',
isa => 'AWS::CloudFront',
lib/AWS/CloudFront/Request.pm view on Meta::CPAN
sub _send_request
{
my ($s, $method, $uri, $headers, $content) = @_;
my $req = HTTP::Request->new( $method => $uri );
$req->content( $content ) if $content;
map {
$req->header( $_ => $headers->{$_} )
} keys %$headers;
view release on metacpan or search on metacpan
lib/AWS/S3.pm view on Meta::CPAN
use Moose;
use Carp 'confess';
use LWP::UserAgent::Determined;
use HTTP::Response;
use HTTP::Request::Common;
use IO::Socket::INET;
use Class::Load 'load_class';
use AWS::S3::ResponseParser;
use AWS::S3::Owner;
view release on metacpan or search on metacpan
lib/AWS/SQS/Simple.pm view on Meta::CPAN
my $response;
until( $got_data or $attempts > 5 ) {
my $request = HTTP::Request->new(
GET => $url_to_access
);
my $ua = LWP::UserAgent->new ;
$ua->timeout(60) ;
view release on metacpan or search on metacpan
lib/AWS/Signature4.pm view on Meta::CPAN
AWS::Signature4 - Create a version4 signature for Amazon Web Services
=head1 SYNOPSIS
use AWS::Signature4;
use HTTP::Request::Common;
use LWP;
my $signer = AWS::Signature4->new(-access_key => 'AKIDEXAMPLE',
-secret_key => 'wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY');
my $ua = LWP::UserAgent->new();
lib/AWS/Signature4.pm view on Meta::CPAN
sub access_key { shift->{access_key } }
sub secret_key { shift->{secret_key } }
=item $signer->sign($request [,$region] [,$payload_sha256_hex])
Given an HTTP::Request object, add the headers required by AWS and
then sign it with a version 4 signature by adding an "Authorization"
header.
The request must include a URL from which the AWS endpoint and service
can be derived, such as "ec2.us-east-1.amazonaws.com." In some cases
lib/AWS/Signature4.pm view on Meta::CPAN
region. In this case, the region can be forced by passing a defined
value for $region. The current date and time will be added to the
request using an "X-Amz-Date header." To force the date and time to a
fixed value, include the "Date" header in the request.
The request content, or "payload" is retrieved from the HTTP::Request
object by calling its content() method.. Under some circumstances the
payload is not included directly in the request, but is in an external
file that will be uploaded as the request is executed. In this case,
you must pass a second argument containing the results of running
sha256_hex() (from the Digest::SHA module) on the content.
lib/AWS/Signature4.pm view on Meta::CPAN
$self->_sign($request,$region,$payload_sha256_hex);
}
=item my $url $signer->signed_url($request_or_uri [,$expires])
Pass an HTTP::Request, a URI object, or just a plain URL string
containing the proper endpoint and parameters needed for an AWS REST
API Call. This method will return an appropriately signed request as a
URI object, which can be shared with non-AWS users for the purpose of,
e.g., accessing an object in a private S3 bucket.
lib/AWS/Signature4.pm view on Meta::CPAN
my $self = shift;
my ($arg1,$expires) = @_;
my ($request,$uri);
if (ref $arg1 && UNIVERSAL::isa($arg1,'HTTP::Request')) {
$request = $arg1;
$uri = $request->uri;
my $content = $request->content;
$uri->query($content) if $content;
if (my $date = $request->header('X-Amz-Date') || $request->header('Date')) {
lib/AWS/Signature4.pm view on Meta::CPAN
}
}
$uri ||= URI->new($arg1);
my $date = $uri->query_param_delete('Date') || $uri->query_param_delete('X-Amz-Date');
$request = HTTP::Request->new(GET=>$uri);
$request->header('Date'=> $date);
$uri = $request->uri; # because HTTP::Request->new() copies the uri!
return $uri if $uri->query_param('X-Amz-Signature');
my $scope = $self->_scope($request);
lib/AWS/Signature4.pm view on Meta::CPAN
return strftime('%Y%m%dT%H%M%SZ',@datetime);
}
sub _hash_canonical_request {
my $self = shift;
my ($request,$hashed_payload) = @_; # (HTTP::Request,sha256_hex($content))
my $method = $request->method;
my $uri = $request->uri;
my $path = $uri->path || '/';
my @params = $uri->query_form;
my $headers = $request->headers;
view release on metacpan or search on metacpan
lib/Acme/AsciiArtFarts.pm view on Meta::CPAN
my $class = shift;
my $self = {};
bless $self, $class;
$self->{ua} = LWP::UserAgent->new();
$self->{uri} = 'http://www.asciiartfarts.com';
$self->{req} = HTTP::Request->new(GET => $self->{uri});
$self->__get_keywords;
$self->{cur_key}= '';
$self->{cur_num}= 0;
$self->{key_arr}= ();
return $self
view release on metacpan or search on metacpan
script/cpan-author.pl view on Meta::CPAN
unlink FILE if -e FILE && time - [stat(FILE)]->[9] > EXP;
if (my $data = eval { local $/; open my $fh, '<', FILE or die $!; <$fh> }) {
warn 'cache';
$_->request(HTTP::Request->new('GET', shift)), return $_ for HTTP::Response->new(200, 'OK', undef, $data);
}
for ($self->SUPER::get(@_)) {
open my $fh, '>', FILE or die $!;
print $fh $_->content;
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlDancerAdvent/2014.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlDancerAdvent::2014;
our $DATE = '2016-11-19'; # DATE
our $VERSION = '0.002'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://advent.perldancer.org/2014/] (retrieved on 2016-11-18). Visit the URL for the full contents.",entries=>[{module=>"DBIx::Class"},{module=>"Dance...
1;
# ABSTRACT: Modules mentioned in PerlDancer Advent Calendar 2014
__END__
lib/Acme/CPANLists/Import/PerlDancerAdvent/2014.pm view on Meta::CPAN
=item * L<Dancer::Test>
=item * L<HTTP::Cookies>
=item * L<HTTP::Request>
=item * L<HTTP::Response>
=item * L<LWP>
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/PerlDancerAdvent/2014.pm view on Meta::CPAN
{ module => "Plack::App::URLMap" },
{ module => "Dancer2::Serializer::CBOR" },
{ module => "Dancer2::Test" },
{ module => "Dancer::Test" },
{ module => "HTTP::Cookies" },
{ module => "HTTP::Request" },
{ module => "HTTP::Response" },
{ module => "LWP" },
{ module => "LWP::Protocol::PSGI" },
{ module => "LWP::UserAgent" },
{ module => "Plack::Test" },
lib/Acme/CPANModules/Import/PerlDancerAdvent/2014.pm view on Meta::CPAN
=item * L<Dancer::Test>
=item * L<HTTP::Cookies>
=item * L<HTTP::Request>
=item * L<HTTP::Response>
=item * L<LWP>