Profile of /usr/local/lib/perl5/site_perl/5.10.1/Net/HTTP.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For 01.HTTP.t
Run on Tue May 4 15:25:55 2010
Reported on Tue May 4 15:26:04 2010

File | /usr/local/lib/perl5/site_perl/5.10.1/Net/HTTP.pm
Statements Executed | 29
Statement Execution Time | 559µs

Subroutines — ordered by exclusive time
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
2 | 1 | 1 | 38µs | 124ms | Net::HTTP::::newNet::HTTP::new
1 | 1 | 1 | 31µs | 35µs | Net::HTTP::::BEGIN@3Net::HTTP::BEGIN@3
2 | 1 | 1 | 22µs | 124ms | Net::HTTP::::http_connectNet::HTTP::http_connect
2 | 1 | 1 | 20µs | 124ms | Net::HTTP::::configureNet::HTTP::configure
1 | 1 | 1 | 12µs | 74µs | Net::HTTP::::BEGIN@4Net::HTTP::BEGIN@4

Call graph for these subroutines as a Graphviz dot language file.

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | package Net::HTTP;
2 |  |  |  |  |
3 | 3 | 34µs | 2 | 39µs | # spent 35µs (31+4) within Net::HTTP::BEGIN@3 which was called # once (31µs+4µs) by LWP::Protocol::implementor at line 3 use strict; # spent 35µs making 1 call to Net::HTTP::BEGIN@3 # spent 4µs making 1 call to strict::import
4 | 3 | 202µs | 2 | 136µs | # spent 74µs (12+62) within Net::HTTP::BEGIN@4 which was called # once (12µs+62µs) by LWP::Protocol::implementor at line 4 use vars qw($VERSION @ISA $SOCKET_CLASS); # spent 74µs making 1 call to Net::HTTP::BEGIN@4 # spent 62µs making 1 call to vars::import
5 |  |  |  |  |
6 | 1 | 800ns |  |  | $VERSION = "5.834";
7 | 1 | 400ns |  |  | unless ($SOCKET_CLASS) {
8 | 2 | 91µs |  |  | eval { require IO::Socket::INET } || require IO::Socket;
9 | 1 | 600ns |  |  | $SOCKET_CLASS = "IO::Socket::INET";
10 |  |  |  |  | }
11 | 1 | 86µs |  |  | require Net::HTTP::Methods;
12 | 1 | 2µs |  |  | require Carp;
13 |  |  |  |  |
14 | 1 | 41µs |  |  | @ISA = ($SOCKET_CLASS, 'Net::HTTP::Methods');
15 |  |  |  |  |
16 |  |  |  |  | # spent 124ms (38µs+124) within Net::HTTP::new which was called 2 times, avg 62.2ms/call: # 2 times (38µs+124ms) by LWP::Protocol::http::_new_socket at line 31 of LWP/Protocol/http.pm, avg 62.2ms/call sub new {
17 | 6 | 45µs |  |  | my $class = shift;
18 |  |  |  |  | Carp::croak("No Host option provided") unless @_;
19 |  |  |  |  | $class->SUPER::new(@_); # spent 124ms making 2 calls to IO::Socket::INET::new, avg 62.2ms/call
20 |  |  |  |  | }
21 |  |  |  |  |
22 |  |  |  |  | # spent 124ms (20µs+124) within Net::HTTP::configure which was called 2 times, avg 62.1ms/call: # 2 times (20µs+124ms) by IO::Socket::new at line 48 of IO/Socket.pm, avg 62.1ms/call sub configure {
23 | 4 | 19µs |  |  | my($self, $cnf) = @_;
24 |  |  |  |  | $self->http_configure($cnf); # spent 124ms making 2 calls to Net::HTTP::Methods::http_configure, avg 62.1ms/call
25 |  |  |  |  | }
26 |  |  |  |  |
27 |  |  |  |  | # spent 124ms (22µs+124) within Net::HTTP::http_connect which was called 2 times, avg 61.9ms/call: # 2 times (22µs+124ms) by Net::HTTP::Methods::http_configure at line 76 of Net/HTTP/Methods.pm, avg 61.9ms/call sub http_connect {
28 | 4 | 22µs |  |  | my($self, $cnf) = @_;
29 |  |  |  |  | $self->SUPER::configure($cnf); # spent 124ms making 2 calls to IO::Socket::INET::configure, avg 61.9ms/call
30 |  |  |  |  | }
31 |  |  |  |  |
32 | 1 | 16µs |  |  | 1;
33 |  |  |  |  |
34 |  |  |  |  | __END__
35 |  |  |  |  |
36 |  |  |  |  | =head1 NAME
37 |  |  |  |  |
38 |  |  |  |  | Net::HTTP - Low-level HTTP connection (client)
39 |  |  |  |  |
40 |  |  |  |  | =head1 SYNOPSIS
41 |  |  |  |  |
42 |  |  |  |  | use Net::HTTP;
43 |  |  |  |  | my $s = Net::HTTP->new(Host => "www.perl.com") || die $@;
44 |  |  |  |  | $s->write_request(GET => "/", 'User-Agent' => "Mozilla/5.0");
45 |  |  |  |  | my($code, $mess, %h) = $s->read_response_headers;
46 |  |  |  |  |
47 |  |  |  |  | while (1) {
48 |  |  |  |  | my $buf;
49 |  |  |  |  | my $n = $s->read_entity_body($buf, 1024);
50 |  |  |  |  | die "read failed: $!" unless defined $n;
51 |  |  |  |  | last unless $n;
52 |  |  |  |  | print $buf;
53 |  |  |  |  | }
54 |  |  |  |  |
55 |  |  |  |  | =head1 DESCRIPTION
56 |  |  |  |  |
57 |  |  |  |  | The C<Net::HTTP> class is a low-level HTTP client. An instance of the
58 |  |  |  |  | C<Net::HTTP> class represents a connection to an HTTP server. The
59 |  |  |  |  | HTTP protocol is described in RFC 2616. The C<Net::HTTP> class
60 |  |  |  |  | supports C<HTTP/1.0> and C<HTTP/1.1>.
61 |  |  |  |  |
62 |  |  |  |  | C<Net::HTTP> is a sub-class of C<IO::Socket::INET>. You can mix the
63 |  |  |  |  | methods described below with reading and writing from the socket
64 |  |  |  |  | directly. This is not necessary a good idea, unless you know what you
65 |  |  |  |  | are doing.
66 |  |  |  |  |
67 |  |  |  |  | The following methods are provided (in addition to those of
68 |  |  |  |  | C<IO::Socket::INET>):
69 |  |  |  |  |
70 |  |  |  |  | =over
71 |  |  |  |  |
72 |  |  |  |  | =item $s = Net::HTTP->new( %options )
73 |  |  |  |  |
74 |  |  |  |  | The C<Net::HTTP> constructor method takes the same options as
75 |  |  |  |  | C<IO::Socket::INET>'s as well as these:
76 |  |  |  |  |
77 |  |  |  |  | Host: Initial host attribute value
78 |  |  |  |  | KeepAlive: Initial keep_alive attribute value
79 |  |  |  |  | SendTE: Initial send_te attribute_value
80 |  |  |  |  | HTTPVersion: Initial http_version attribute value
81 |  |  |  |  | PeerHTTPVersion: Initial peer_http_version attribute value
82 |  |  |  |  | MaxLineLength: Initial max_line_length attribute value
83 |  |  |  |  | MaxHeaderLines: Initial max_header_lines attribute value
84 |  |  |  |  |
85 |  |  |  |  | The C<Host> option is also the default for C<IO::Socket::INET>'s
86 |  |  |  |  | C<PeerAddr>. The C<PeerPort> defaults to 80 if not provided.
87 |  |  |  |  |
88 |  |  |  |  | The C<Listen> option provided by C<IO::Socket::INET>'s constructor
89 |  |  |  |  | method is not allowed.
90 |  |  |  |  |
91 |  |  |  |  | If unable to connect to the given HTTP server then the constructor
92 |  |  |  |  | returns C<undef> and $@ contains the reason. After a successful
93 |  |  |  |  | connect, a C<Net:HTTP> object is returned.
94 |  |  |  |  |
95 |  |  |  |  | =item $s->host
96 |  |  |  |  |
97 |  |  |  |  | Get/set the default value of the C<Host> header to send. The $host
98 |  |  |  |  | must not be set to an empty string (or C<undef>) for HTTP/1.1.
99 |  |  |  |  |
100 |  |  |  |  | =item $s->keep_alive
101 |  |  |  |  |
102 |  |  |  |  | Get/set the I<keep-alive> value. If this value is TRUE then the
103 |  |  |  |  | request will be sent with headers indicating that the server should try
104 |  |  |  |  | to keep the connection open so that multiple requests can be sent.
105 |  |  |  |  |
106 |  |  |  |  | The actual headers set will depend on the value of the C<http_version>
107 |  |  |  |  | and C<peer_http_version> attributes.
108 |  |  |  |  |
109 |  |  |  |  | =item $s->send_te
110 |  |  |  |  |
111 |  |  |  |  | Get/set the a value indicating if the request will be sent with a "TE"
112 |  |  |  |  | header to indicate the transfer encodings that the server can choose to
113 |  |  |  |  | use. The list of encodings announced as accepted by this client depends
114 |  |  |  |  | on availability of the following modules: C<Compress::Raw::Zlib> for
115 |  |  |  |  | I<deflate>, and C<IO::Compress::Gunzip> for I<gzip>.
116 |  |  |  |  |
117 |  |  |  |  | =item $s->http_version
118 |  |  |  |  |
119 |  |  |  |  | Get/set the HTTP version number that this client should announce.
120 |  |  |  |  | This value can only be set to "1.0" or "1.1". The default is "1.1".
121 |  |  |  |  |
122 |  |  |  |  | =item $s->peer_http_version
123 |  |  |  |  |
124 |  |  |  |  | Get/set the protocol version number of our peer. This value will
125 |  |  |  |  | initially be "1.0", but will be updated by a successful
126 |  |  |  |  | read_response_headers() method call.
127 |  |  |  |  |
128 |  |  |  |  | =item $s->max_line_length
129 |  |  |  |  |
130 |  |  |  |  | Get/set a limit on the length of response line and response header
131 |  |  |  |  | lines. The default is 8192. A value of 0 means no limit.
132 |  |  |  |  |
133 |  |  |  |  | =item $s->max_header_length
134 |  |  |  |  |
135 |  |  |  |  | Get/set a limit on the number of header lines that a response can
136 |  |  |  |  | have. The default is 128. A value of 0 means no limit.
137 |  |  |  |  |
138 |  |  |  |  | =item $s->format_request($method, $uri, %headers, [$content])
139 |  |  |  |  |
140 |  |  |  |  | Format a request message and return it as a string. If the headers do
141 |  |  |  |  | not include a C<Host> header, then a header is inserted with the value
142 |  |  |  |  | of the C<host> attribute. Headers like C<Connection> and
143 |  |  |  |  | C<Keep-Alive> might also be added depending on the status of the
144 |  |  |  |  | C<keep_alive> attribute.
145 |  |  |  |  |
146 |  |  |  |  | If $content is given (and it is non-empty), then a C<Content-Length>
147 |  |  |  |  | header is automatically added unless it was already present.
148 |  |  |  |  |
149 |  |  |  |  | =item $s->write_request($method, $uri, %headers, [$content])
150 |  |  |  |  |
151 |  |  |  |  | Format and send a request message. Arguments are the same as for
152 |  |  |  |  | format_request(). Returns true if successful.
153 |  |  |  |  |
154 |  |  |  |  | =item $s->format_chunk( $data )
155 |  |  |  |  |
156 |  |  |  |  | Returns the string to be written for the given chunk of data.
157 |  |  |  |  |
158 |  |  |  |  | =item $s->write_chunk($data)
159 |  |  |  |  |
160 |  |  |  |  | Will write a new chunk of request entity body data. This method
161 |  |  |  |  | should only be used if the C<Transfer-Encoding> header with a value of
162 |  |  |  |  | C<chunked> was sent in the request. Note, writing zero-length data is
163 |  |  |  |  | a no-op. Use the write_chunk_eof() method to signal end of entity
164 |  |  |  |  | body data.
165 |  |  |  |  |
166 |  |  |  |  | Returns true if successful.
167 |  |  |  |  |
168 |  |  |  |  | =item $s->format_chunk_eof( %trailers )
169 |  |  |  |  |
170 |  |  |  |  | Returns the string to be written for signaling EOF when a
171 |  |  |  |  | C<Transfer-Encoding> of C<chunked> is used.
172 |  |  |  |  |
173 |  |  |  |  | =item $s->write_chunk_eof( %trailers )
174 |  |  |  |  |
175 |  |  |  |  | Will write eof marker for chunked data and optional trailers. Note
176 |  |  |  |  | that trailers should not really be used unless is was signaled
177 |  |  |  |  | with a C<Trailer> header.
178 |  |  |  |  |
179 |  |  |  |  | Returns true if successful.
180 |  |  |  |  |
181 |  |  |  |  | =item ($code, $mess, %headers) = $s->read_response_headers( %opts )
182 |  |  |  |  |
183 |  |  |  |  | Read response headers from server and return it. The $code is the 3
184 |  |  |  |  | digit HTTP status code (see L<HTTP::Status>) and $mess is the textual
185 |  |  |  |  | message that came with it. Headers are then returned as key/value
186 |  |  |  |  | pairs. Since key letter casing is not normalized and the same key can
187 |  |  |  |  | even occur multiple times, assigning these values directly to a hash
188 |  |  |  |  | is not wise. Only the $code is returned if this method is called in
189 |  |  |  |  | scalar context.
190 |  |  |  |  |
191 |  |  |  |  | As a side effect this method updates the 'peer_http_version'
192 |  |  |  |  | attribute.
193 |  |  |  |  |
194 |  |  |  |  | Options might be passed in as key/value pairs. There are currently
195 |  |  |  |  | only two options supported; C<laxed> and C<junk_out>.
196 |  |  |  |  |
197 |  |  |  |  | The C<laxed> option will make read_response_headers() more forgiving
198 |  |  |  |  | towards servers that have not learned how to speak HTTP properly. The
199 |  |  |  |  | C<laxed> option is a boolean flag, and is enabled by passing in a TRUE
200 |  |  |  |  | value. The C<junk_out> option can be used to capture bad header lines
201 |  |  |  |  | when C<laxed> is enabled. The value should be an array reference.
202 |  |  |  |  | Bad header lines will be pushed onto the array.
203 |  |  |  |  |
204 |  |  |  |  | The C<laxed> option must be specified in order to communicate with
205 |  |  |  |  | pre-HTTP/1.0 servers that don't describe the response outcome or the
206 |  |  |  |  | data they send back with a header block. For these servers
207 |  |  |  |  | peer_http_version is set to "0.9" and this method returns (200,
208 |  |  |  |  | "Assumed OK").
209 |  |  |  |  |
210 |  |  |  |  | The method will raise an exception (die) if the server does not speak
211 |  |  |  |  | proper HTTP or if the C<max_line_length> or C<max_header_length>
212 |  |  |  |  | limits are reached. If the C<laxed> option is turned on and
213 |  |  |  |  | C<max_line_length> and C<max_header_length> checks are turned off,
214 |  |  |  |  | then no exception will be raised and this method will always
215 |  |  |  |  | return a response code.
216 |  |  |  |  |
217 |  |  |  |  | =item $n = $s->read_entity_body($buf, $size);
218 |  |  |  |  |
219 |  |  |  |  | Reads chunks of the entity body content. Basically the same interface
220 |  |  |  |  | as for read() and sysread(), but the buffer offset argument is not
221 |  |  |  |  | supported yet. This method should only be called after a successful
222 |  |  |  |  | read_response_headers() call.
223 |  |  |  |  |
224 |  |  |  |  | The return value will be C<undef> on read errors, 0 on EOF, -1 if no data
225 |  |  |  |  | could be returned this time, otherwise the number of bytes assigned
226 |  |  |  |  | to $buf. The $buf is set to "" when the return value is -1.
227 |  |  |  |  |
228 |  |  |  |  | You normally want to retry this call if this function returns either
229 |  |  |  |  | -1 or C<undef> with C<$!> as EINTR or EAGAIN (see L<Errno>). EINTR
230 |  |  |  |  | can happen if the application catches signals and EAGAIN can happen if
231 |  |  |  |  | you made the socket non-blocking.
232 |  |  |  |  |
233 |  |  |  |  | This method will raise exceptions (die) if the server does not speak
234 |  |  |  |  | proper HTTP. This can only happen when reading chunked data.
235 |  |  |  |  |
236 |  |  |  |  | =item %headers = $s->get_trailers
237 |  |  |  |  |
238 |  |  |  |  | After read_entity_body() has returned 0 to indicate end of the entity
239 |  |  |  |  | body, you might call this method to pick up any trailers.
240 |  |  |  |  |
241 |  |  |  |  | =item $s->_rbuf
242 |  |  |  |  |
243 |  |  |  |  | Get/set the read buffer content. The read_response_headers() and
244 |  |  |  |  | read_entity_body() methods use an internal buffer which they will look
245 |  |  |  |  | for data before they actually sysread more from the socket itself. If
246 |  |  |  |  | they read too much, the remaining data will be left in this buffer.
247 |  |  |  |  |
248 |  |  |  |  | =item $s->_rbuf_length
249 |  |  |  |  |
250 |  |  |  |  | Returns the number of bytes in the read buffer. This should always be
251 |  |  |  |  | the same as:
252 |  |  |  |  |
253 |  |  |  |  | length($s->_rbuf)
254 |  |  |  |  |
255 |  |  |  |  | but might be more efficient.
256 |  |  |  |  |
257 |  |  |  |  | =back
258 |  |  |  |  |
259 |  |  |  |  | =head1 SUBCLASSING
260 |  |  |  |  |
261 |  |  |  |  | The read_response_headers() and read_entity_body() will invoke the
262 |  |  |  |  | sysread() method when they need more data. Subclasses might want to
263 |  |  |  |  | override this method to control how reading takes place.
264 |  |  |  |  |
265 |  |  |  |  | The object itself is a glob. Subclasses should avoid using hash key
266 |  |  |  |  | names prefixed with C<http_> and C<io_>.
267 |  |  |  |  |
268 |  |  |  |  | =head1 SEE ALSO
269 |  |  |  |  |
270 |  |  |  |  | L<LWP>, L<IO::Socket::INET>, L<Net::HTTP::NB>
271 |  |  |  |  |
272 |  |  |  |  | =head1 COPYRIGHT
273 |  |  |  |  |
274 |  |  |  |  | Copyright 2001-2003 Gisle Aas.
275 |  |  |  |  |
276 |  |  |  |  | This library is free software; you can redistribute it and/or
277 |  |  |  |  | modify it under the same terms as Perl itself.
278 |  |  |  |  |
279 |  |  |  |  | =cut