Any-Daemon-HTTP

 view release on metacpan or  search on metacpan

lib/Any/Daemon/FCGI.pm  view on Meta::CPAN

use Log::Report      'any-daemon-http';

use Any::Daemon::FCGI::ClientConn ();


sub new(%)
{   my ($class, %args) = @_;
    $args{Listen} ||= 5;
    $args{Proto}  ||= 'tcp';
    $class->SUPER::new(%args);
}

#----------------

#----------------

sub accept(;$)
{   my $self = shift;
    my $pkg  = shift // 'Any::Daemon::FCGI::ClientConn';
    $self->SUPER::accept($pkg);
}

1;

lib/Any/Daemon/FCGI/Request.pm  view on Meta::CPAN

    push @headers, 'Content-Length' => $params->{CONTENT_LENGTH}
        if exists $params->{CONTENT_LENGTH};
 
    # Pull all the HTTP_FOO parameters as headers. These will be in all-caps
    # and use _ for word separators, but HTTP::Headers can cope with that.
    foreach (keys %$params)
    {   push @headers, $1 => $params->{$_} if m/^HTTP_(.*)$/;
    }
 
    my $self   = $class->SUPER::new
      ( $params->{REQUEST_METHOD}
      , $params->{REQUEST_URI}
      , \@headers
      , $args->{stdin}
      );

    $self->protocol($params->{SERVER_PROTOCOL});

    $self->{ADFR_reqid}  = $args->{request_id} or panic;
    $self->{ADFR_params} = $params;

lib/Any/Daemon/HTTP.pm  view on Meta::CPAN

  };

# To support IPv6, replace ::INET by ::IP
@HTTP::Daemon::ClientConn::ISA = qw(IO::Socket::IP);


sub _to_list($) { ref $_[0] eq 'ARRAY' ? @{$_[0]} : defined $_[0] ? $_[0] : () }

sub init($)
{   my ($self, $args) = @_;
    $self->SUPER::init($args);

    my $listen = $args->{listen} || $args->{socket} || $args->{host};
    my (@sockets, @hosts);
    foreach my $conn (_to_list $listen)
    {   my ($socket, @host) = $self->_create_socket($conn
          , protocol => $args->{protocol}
          );

        push @sockets, $socket if $socket;
        push @hosts, @host;

lib/Any/Daemon/HTTP.pm  view on Meta::CPAN

                last CONNECTION
                    if $conn_count++ >= $max_conn
                    || $req_count    >= $max_req;
            }
            $self->psTitle("$title idle after $conn_count");
        }
        0;
    };

    info __x"start running the webserver";
    $self->SUPER::run(%args);
}


sub newConnection($)
{   my ($self, $session) = @_;
    return $self;
}


sub newChild($)

lib/Any/Daemon/HTTP/Directory.pm  view on Meta::CPAN

use Encode         qw/encode/;
use MIME::Types    ();

my $mimetypes = MIME::Types->new(only_complete => 1);

sub _filename_trans($$);


sub init($)
{   my ($self, $args) = @_;
    $self->SUPER::init($args);

    my $path = $self->path;
    my $loc  = $args->{location}
        or error __x"directory definition requires location";

    my $trans;
    if(ref $loc eq 'CODE')
    {   $trans = $loc;
        undef $loc;
    }

lib/Any/Daemon/HTTP/Proxy.pm  view on Meta::CPAN

use Log::Report    'any-daemon-http';

use LWP::UserAgent ();
use HTTP::Status   qw(HTTP_TOO_MANY_REQUESTS);
use Time::HiRes    qw(time);


sub init($)
{   my ($self, $args) = @_;
    $self->SUPER::init($args);

    $self->{ADHDP_ua}  = $args->{user_agent}
      || LWP::UserAgent->new(keep_alive => 30);

    $self->{ADHDP_via} = $args->{via};
    if(my $fm = $args->{forward_map})
    {   $self->{ADHDP_map}   = $fm eq 'RELAY' ? sub {$_[3]} : $fm;
    }

    if(my $rem = $args->{remote_proxy})

lib/Any/Daemon/HTTP/Source.pod  view on Meta::CPAN

    ], ...

B<. Example: create own access rules>

If you have an ::VirtualHost extension class, you do this:

 sub allow($$$)
 {   my ($self, $session, $request, $uri) = @_;

     # General rules may refuse access already
     $self->SUPER::allow($session, $request, $uri)
         or return 0;

     # here your own checks
     # $session is a Any::Daemon::HTTP::Session
     # $request is a HTTP::Request
     # $uri     is a URI::

     1;
 }

lib/Any/Daemon/HTTP/UserDirs.pm  view on Meta::CPAN

sub init($)
{   my ($self, $args) = @_;

    my $subdirs = $args->{user_subdirs} || 'public_html';
    my %allow   = map +($_ => 1), @{$args->{allow_users} || []};
    my %deny    = map +($_ => 1), @{$args->{deny_users}  || []};
    $args->{location} ||= $self->userdirRewrite($subdirs, \%allow, \%deny);

    $self->SUPER::init($args);
    $self;
}

#-----------------

sub userdirRewrite($$$)
{   my ($self, $udsub, $allow, $deny) = @_;
    my %homes;  # cache
    sub { my $path = shift;
          my ($user, $pathinfo) = $path =~ m!^/\~([^/]*)(.*)!;

lib/Any/Daemon/HTTP/VirtualHost.pod  view on Meta::CPAN

or configation files.  For that, extend L<Any::Daemon::HTTP::Session|Any::Daemon::HTTP::Session>.

B<. Example: own virtual host>

  package My::Service;
  use parent 'Any::Daemon::HTTP::VirtualHost';

  sub init($)
  {   my ($self, $args) = @_;
      $args->{session_class} = 'My::Service::Session';
      $self->SUPER::init($args);
      
      $self->addDirectory(...);
      $self->addHandler(a => 'ah');
      ... etc ...
      $self;
  }

  sub ah($$$$)
  {   my ($self, $session, $request, $uri, $tree) = @_;
      return HTTP::Response->new(...);