view release on metacpan or  search on metacpan

lib/Haineko/HTTPD.pm  view on Meta::CPAN

    $argvs->{'router'}   ||= Haineko::HTTPD::Router->new;
    $argvs->{'request'}  ||= Haineko::HTTPD::Request->new;
    $argvs->{'response'} ||= Haineko::HTTPD::Response->new;

    $argvs->{'host'}  = $argvs->{'request'}->env->{'SERVER_NAME'};
    $argvs->{'debug'} = $ENV{'HAINEKO_DEBUG'} ? 1 : 0;

    return bless $argvs, __PACKAGE__;
}

sub start {
    my $class = shift;
    my $nyaaa = sub {
        my $hainekoenv = shift;
        my $htresponse = undef;
        my $requestnya = Haineko::HTTPD::Request->new( $hainekoenv );
        my $contextnya = $class->new( 'request' => $requestnya );

        local *Haineko::HTTPD::context = sub { $contextnya };
        $htresponse = $class->startup( $contextnya );

        return $htresponse->finalize;
    };

    return $nyaaa;
}

sub req {
    my $self = shift;
    return $self->request;
}

sub res {
    my $self = shift;
    return $self->response;
}

sub rdr {
    my $self = shift;
    my $code = shift || 302;
    my $next = shift;

    $self->response->redirect( $next, $code );
    return $self->response;
}

sub err {
    my $self = shift;
    my $code = shift || 404;
    my $mesg = shift;

    unless( $mesg ) {
        # If the second argument is omitted, use "404 Not found" as a JSON.
        require Haineko::SMTPD::Response;
        $mesg = Haineko::SMTPD::Response->r( 'http', 'not-found' )->damn;
    }

    if( ref $mesg eq 'HASH' ) {
        # Respond as a JSON
        require Haineko::SMTPD::Session;
        my $addr = [ split( ',', $self->req->header('X-Forwarded-For') || q() ) ];
        my $sess = Haineko::SMTPD::Session->new( 
                        'referer'    => $self->req->referer // undef,
                        'response'   => [ $mesg ],
                        'remoteaddr' => pop @$addr || $self->req->address // undef,
                        'remoteport' => $self->req->env->{'REMOTE_ADDR'} // undef,
                        'useragent'  => $self->req->user_agent // undef,
                   )->damn;
        $sess->{'queueid'} = undef;
        return $self->response->json( $code, $sess );

    } else {
        # Respond as a text
        $self->response->code( $code );
        $self->response->content_type( 'text/plain' );
        $self->response->content_length( length $mesg );
        $self->response->body( $mesg );
        return $self->response;
    }
}

sub r {
    my $self = shift;
    my $neko = $self->router->routematch( $self->req->env );

    return $self->err unless $neko;

    my $controller = sprintf( "Haineko::%s", $neko->dest->{'controller'} );
    my $ctrlaction = $neko->dest->{'action'};
    my $exceptions = 0;
    my $htcontents = undef;
    my $nekosyslog = undef;

    try {
        require Module::Load;
        Module::Load::load( $controller );

    } catch {
        require Haineko::Log;
        require Haineko::SMTPD::Response;

        $htcontents = Haineko::SMTPD::Response->r( 'http', 'server-error' )->damn;
        $nekosyslog = Haineko::Log->new( 'disabled' => 0 );

        $htcontents->{'message'}->[1] = $_;
        $nekosyslog->w( 'crit', $htcontents );
        pop @{ $htcontents->{'message'} } unless $self->debug;
        $exceptions = 1;
    };

    return $controller->$ctrlaction( $self ) unless $exceptions;
    return $self->err( 500, { 'response' => $htcontents } );
}

1;
__END__
=encoding utf-8

=head1 NAME

Haineko::HTTPD - Something like web application framework