Apache-HeavyCGI
view release on metacpan or search on metacpan
lib/Apache/HeavyCGI.pm view on Meta::CPAN
my $r = $self->{R};
# warn "Going to send_http_header";
$r->send_http_header;
return OK if $r->method eq "HEAD";
# warn "Going to print content";
$r->print($self->{CONTENT});
DONE; # we've sent the headers and the body, apache shouldn't talk
# to the browser anymore
}
sub handler {
warn "The handler of the request hasn't defined a handler subroutine.";
__PACKAGE__->new( R => shift )->dispatch;
}
sub dispatch {
my Apache::HeavyCGI $self = shift;
$self->init;
eval { $self->prepare; };
if ($@) {
if (UNIVERSAL::isa($@,"Apache::HeavyCGI::Exception")) {
if ($@->{ERROR}) {
warn "\$\@ ERROR[$@->{ERROR}]";
$@->{ERROR} = [ $@->{ERROR} ] unless ref $@->{ERROR};
warn "\$\@ ERROR[$@->{ERROR}]";
push @{$self->{ERROR}}, @{$@->{ERROR}};
warn "self ERROR[$self->{ERROR}]";
} elsif ($@->{HTTP_STATUS}) {
return $@->{HTTP_STATUS};
}
} else {
# this is not a known error type, we need to handle it anon
if ($self->{ERRORS_TO_BROWSER}) {
push @{$self->{ERROR}}, " ", $@;
} else {
$self->{R}->log_error($@);
return SERVER_ERROR;
}
}
}
return $self->{DONE} if $self->{DONE}; # backwards comp now, will go away
$self->{CONTENT} = $self->layout->as_string($self);
$self->finish;
$self->deliver;
}
sub expires {
my Apache::HeavyCGI $self = shift;
my($set) = @_;
$set = Apache::HeavyCGI::Date->new(unix => $set)
if defined($set) and not ref($set); # allow setting to a number
$self->{EXPIRES} = $set if defined $set;
return $self->{EXPIRES}; # even if not defined $self->{EXPIRES};
}
sub finish {
my Apache::HeavyCGI $self = shift;
my $r = $self->{R};
my $content_type = "text/html";
$content_type .= "; charset=$self->{CHARSET}" if defined $self->{CHARSET};
$r->content_type($content_type);
eval { require Compress::Zlib; };
$self->{CAN_GZIP} = 0 if $@; # we cannot compress anyway :-)
if ($self->can_gzip) {
$r->header_out('Content-Encoding', 'gzip');
$self->{CONTENT} = Compress::Zlib::memGzip($self->{CONTENT});
}
$r->header_out('Vary', join ", ", 'accept-encoding');
$r->header_out('Expires', $self->expires->http) if $self->expires;
$r->header_out('Last-Modified',$self->last_modified->http);
$r->header_out('Content-Length', length($self->{CONTENT}));
}
sub init {
return;
}
sub instance_of {
my($self,$class) = @_;
return $class->instance if $class->can("instance");
my $requirefile = $class;
$requirefile =~ s/::/\//g;
$requirefile .= ".pm";
# warn "requiring[$requirefile]";
require $requirefile;
$class->instance;
}
sub layout {
my Apache::HeavyCGI $self = shift;
require Apache::HeavyCGI::Layout;
my @l;
push @l, qq{<html><head><title>Apache::HeavyCGI default page</title>
</head><body><pre>};
push @l, $self->instance_of("Apache::HeavyCGI::Debug");
push @l, qq{</pre></body></html>};
Apache::HeavyCGI::Layout->new(@l);
}
sub last_modified {
my Apache::HeavyCGI $self = shift;
my($set) = @_;
$set = Apache::HeavyCGI::Date->new(unix => $set)
if defined($set) and not ref($set); # allow setting to a number
$self->{LAST_MODIFIED} = $set if defined $set;
return $self->{LAST_MODIFIED} if defined $self->{LAST_MODIFIED};
$self->{LAST_MODIFIED} =
Apache::HeavyCGI::Date->new(unix => $self->time);
}
sub myurl {
my Apache::HeavyCGI $self = shift;
return $self->{MYURL} if defined $self->{MYURL};
require URI::URL;
my $r = $self->{R} or
return URI::URL->new("http://localhost");
my $script_name = substr(
lib/Apache/HeavyCGI.pm view on Meta::CPAN
+----------------------------+----------------------------------------+----+
|Apache | calls Your::Class::handler() | |
+----------------------------+----------------------------------------+----+
| | nominates the handlers, | |
|Your::Class::handler() | constructs $self, | ** |
| | and calls $self->dispatch | |
+----------------------------+----------------------------------------+----+
| | $self->init (does nothing) | ?? |
| | $self->prepare (see below) | |
|Apache::HeavyCGI::dispatch()| calls $self->layout (sets up layout)| ** |
| | $self->finish (headers and | ** |
| | gross content) | |
| | $self->deliver (delivers) | ?? |
+----------------------------+----------------------------------------+----+
|Apache::HeavyCGI::prepare() | calls HANDLER->instance->header($self) | ** |
| | and HANDLER->instance->parameter($self)| ** |
| | on all of your nominated handlers | |
+----------------------------+----------------------------------------+----+
=head1 Object Attributes
As already mentioned, the HeavyCGI object is a pseudo-hash, i.e. can
be treated like a HASH, but all attributes that are being used must be
predeclared at compile time with a C<use fields> clause.
The convention regarding attributes is as simple as it can be:
uppercase attributes are reserved for the Apache::HeavyCGI class, all
other attribute names are at your disposition if you write a subclass.
The following attributes are currently defined. The module author's
production environment has a couple of attributes more that seem to
work well but most probably need more thought to be implemented in a
generic way.
=over
=item CAN_GZIP
Set by the can_gzip method. True if client is able to handle gzipped
data.
=item CAN_PNG
Set by the can_png method. True if client is able to handle PNG.
=item CAN_UTF8
Set by the can_utf8 method. True if client is able to handle UTF8
endoded data.
=item CGI
An object that handles GET and POST parameters and offers the method
param() and upload() in a manner compatible with Apache::Request.
Needs to be constructed and set by the user typically in the
contructor.
=item CHARSET
Optional attribute to denote the charset in which the outgoing data
are being encoded. Only used within the finish method. If it is set,
the finish() method will set the content type to text/html with this
charset.
=item CONTENT
Scalar that contains the content that should be sent to the user
uncompressed. During te finish() method the content may become
compressed.
=item DOCUMENT_ROOT
Unused.
=item ERROR
Anonymous array that accumulates error messages. HeavyCGI doesn't
handle the error though. It is left to the user to set up a proper
response to the user.
=item EXECUTION_PLAN
Object of type L<Apache::HeavyCGI::ExePlan>. It is recommended to
compute the object at startup time and always pass the same execution
plan into the constructor.
=item EXPIRES
Optional Attribute set by the expires() method. If set, HeavyCGI will
send an Expires header. The EXPIRES attribute needs to contain an
L<Apache::HeavyCGI::Date> object.
=item HANDLER
If there is an EXECUTION_PLAN, this attribute is ignored. Without an
EXECUTION_PLAN, it must be an array of package names. HeavyCGI treats
the packages as Class::Singleton classes. During the prepare() method
HeavyCGI calls HANDLER->instance->header($self) and
HANDLER->instance->parameter($self) on all of your nominated handlers.
=item LAST_MODIFIED
Optional Attribute set by the last_modified() method. If set, HeavyCGI
will send a Last-Modified header of the specified time, otherwise it
sends a Last-Modified header of the current time. The attribute needs
to contain an L<Apache::HeavyCGI::Date> object.
=item MYURL
The URL of the running request set by the myurl() method. Contains an
URI::URL object.
=item R
The Apache Request object for the running request. Needs to be set up
in the constructor by the user.
=item REFERER
Unused.
=item SERVERROOT_URL
( run in 2.879 seconds using v1.01-cache-2.11-cpan-99c4e6809bf )