| 1 | ##-*- Mode: CPerl -*- | ||
| 2 | |||
| 3 | ## File: DTA::CAB::Server::HTTP::Handler::Query.pm | ||
| 4 | ## Author: Bryan Jurish <moocow@cpan.org> | ||
| 5 | ## Description: | ||
| 6 | ## + CAB HTTP Server: request handler: analyzer queries by CGI form | ||
| 7 | ##====================================================================== | ||
| 8 | |||
| 9 | package DTA::CAB::Server::HTTP::Handler::Query; | ||
| 10 | use DTA::CAB::Server::HTTP::Handler::CGI; | ||
| 11 | use HTTP::Status; | ||
| 12 | use URI::Escape qw(uri_escape uri_escape_utf8); | ||
| 13 | use CGI ':standard'; | ||
| 14 | use Carp; | ||
| 15 | use strict; | ||
| 16 | |||
| 17 | ##-------------------------------------------------------------- | ||
| 18 | ## Globals | ||
| 19 | |||
| 20 | our @ISA = qw(DTA::CAB::Server::HTTP::Handler::CGI); | ||
| 21 | |||
| 22 | ##-------------------------------------------------------------- | ||
| 23 | ## Aliases | ||
| 24 | BEGIN { | ||
| 25 | DTA::CAB::Server::HTTP::Handler->registerAlias( | ||
| 26 | 'Query' => __PACKAGE__, | ||
| 27 | 'analyzerCGI' => __PACKAGE__, | ||
| 28 | 'analyzercgi' => __PACKAGE__, | ||
| 29 | ); | ||
| 30 | } | ||
| 31 | |||
| 32 | ##-------------------------------------------------------------- | ||
| 33 | ## Methods: API | ||
| 34 | |||
| 35 | ## $h = $class_or_obj->new(%options) | ||
| 36 | ## %$h, %options: | ||
| 37 | ## ( | ||
| 38 | ## ##-- INHERITED from Handler::CGI | ||
| 39 | ## #encoding => $defaultEncoding, ##-- default encoding (now always UTF-8) | ||
| 40 | ## allowGet => $bool, ##-- allow GET requests? (default=1) | ||
| 41 | ## allowPost => $bool, ##-- allow POST requests? (default=1) | ||
| 42 | ## #allowList => $bool, ##-- if true, allowed analyzers will be listed for 'PATHROOT/.../list' paths | ||
| 43 | ## pushMode => $mode, ##-- push mode for addVars (default='keep') | ||
| 44 | ## ## | ||
| 45 | ## ##-- NEW in Handler::Query | ||
| 46 | ## maxRequestSize => $bytes, ##-- maximum allowable request size (content-length in bytes; default: undef//-1: no max) | ||
| 47 | ## prefix => $prefix, ##-- analyzer name prefix (automatically trimmed; default='dta.cab.') | ||
| 48 | ## allowAnalyzers => \%analyzers, ##-- set of allowed analyzers ($allowedAnalyzerName=>$bool, ...) -- default=undef (all allowed) | ||
| 49 | ## defaultAnalyzer => $aname, ##-- default analyzer name (default = 'default') | ||
| 50 | ## formats => $registry, ##-- registry of allowed formats; default=$DTA::CAB::Format::REG | ||
| 51 | ## defaultFormat => $class, ##-- default format (default=$DTA::CAB::Format::CLASS_DEFAULT) | ||
| 52 | ## allowUserOptions => $bool, ##-- allow user options to analyzeDocument()? (default=1) | ||
| 53 | ## forceClean => $bool, ##-- always appends 'doAnalyzeClean'=>1 to options if true (default=false) | ||
| 54 | ## returnRaw => $bool, ##-- return all data as text/plain? (default=0) | ||
| 55 | ## logVars => $level, ##-- log-level for variable expansion (default=undef: none) | ||
| 56 | ## ) | ||
| 57 | sub new { | ||
| 58 | my $that = shift; | ||
| 59 | my $h = $that->SUPER::new( | ||
| 60 | #encoding=>'UTF-8', ##-- default CGI parameter encoding (now always UTF-8) | ||
| 61 | allowGet=>1, | ||
| 62 | allowPost=>1, | ||
| 63 | maxRequestSize=>undef, | ||
| 64 | logVars => undef, | ||
| 65 | pushMode => 'keep', | ||
| 66 | allowAnalyzers=>undef, | ||
| 67 | prefix => 'dta.cab.', | ||
| 68 | defaultAnalyzer=>'default', | ||
| 69 | formats => $DTA::CAB::Format::REG, | ||
| 70 | defaultFormat => $DTA::CAB::Format::CLASS_DEFAULT, | ||
| 71 | allowUserOptions => 1, | ||
| 72 | forceClean => 0, | ||
| 73 | returnRaw => 0, | ||
| 74 | @_, | ||
| 75 | ); | ||
| 76 | return $h; | ||
| 77 | } | ||
| 78 | |||
| 79 | ## $bool = $h->prepare($server) | ||
| 80 | ## + sets $h->{allowAnalyzers} if not already defined | ||
| 81 | sub prepare { | ||
| 82 | my ($h,$srv) = @_; | ||
| 83 | $h->{allowAnalyzers} = { map {($_=>1)} keys %{$srv->{as}} } if (!$h->{allowAnalyzers}); | ||
| 84 | return 1; | ||
| 85 | } | ||
| 86 | |||
| 87 | ## $bool = $path->run($server, $localPath, $clientSocket, $httpRequest) | ||
| 88 | ## + process $httpRequest as CGI form-encoded query | ||
| 89 | ## | ||
| 90 | ## + analyzer list | ||
| 91 | ## if $localPath ends in '/list', a list of analyzers will be returned, | ||
| 92 | ## encoded accroding to the 'format' form variable. | ||
| 93 | ## | ||
| 94 | ## + form parameters: | ||
| 95 | ## ( | ||
| 96 | ## q => $queryString, ##-- raw, untokenized query string (preferred over 'qd') | ||
| 97 | ## qd => $queryData, ##-- query data (formatted document) | ||
| 98 | ## a => $analyzerName, ##-- analyzer key in %{$h->{allowAnalyzers}}, %{$srv->{as}} | ||
| 99 | ## fmt => $queryFormat, ##-- query/response format (set 'ifmt', 'ofmt' simultaneously) | ||
| 100 | ## ifmt => $inputFormat, ##-- query INPUT format (default=$h->{defaultFormat}) | ||
| 101 | ## ofmt => $outputFormat, ##-- response OUTPUT format (default=$inputFormat) | ||
| 102 | ## file => $qfilename, ##-- query filename (for output) | ||
| 103 | ## #enc => $queryEncoding, ##-- query encoding (default='UTF-8') | ||
| 104 | ## raw => $bool, ##-- if true, data will be returned as text/plain (default=$h->{returnRaw}) | ||
| 105 | ## pretty => $level, ##-- response format level | ||
| 106 | ## clean => $clean, ##-- request doAnalyzeClean() if true | ||
| 107 | ## ## | ||
| 108 | ## $opt => $value, ##-- other options are passed to analyzeDocument() (if $h->{allowUserOptions} is true) | ||
| 109 | ## ) | ||
| 110 | our %localParams = map {($_=>undef)} qw(q qd a fmt ifmt ofmt raw pretty clean); | ||
| 111 | sub run { | ||
| 112 | my ($h,$srv,$path,$c,$hreq) = @_; | ||
| 113 | |||
| 114 | ##-- check for HEAD | ||
| 115 | return $h->headResponse() if ($hreq->method eq 'HEAD'); | ||
| 116 | |||
| 117 | ##-- check for LIST | ||
| 118 | my @upath = $hreq->uri->path_segments; | ||
| 119 | return $h->runList($srv,$path,$c,$hreq) if ($upath[$#upath] eq 'list'); | ||
| 120 | |||
| 121 | ##-- check request size | ||
| 122 | if (($h->{maxRequestSize}//-1) >= 0 && ($hreq->content_length//0) > $h->{maxRequestSize}) { | ||
| 123 | return $h->cerror($c, RC_REQUEST_ENTITY_TOO_LARGE, "request content exceeds handler limit (max=$h->{maxRequestSize} bytes)"); | ||
| 124 | } | ||
| 125 | |||
| 126 | ##-- parse query parameters | ||
| 127 | my $vars = $h->cgiParams($c,$hreq,defaultName=>'qd') or return undef; | ||
| 128 | return $h->cerror($c, undef, "no query parameters specified!") if (!$vars || !%$vars); | ||
| 129 | $h->vlog($h->{logVars}, "got query params:\n", Data::Dumper->Dump([$vars],['vars'])) if ($h->{logVars}); | ||
| 130 | |||
| 131 | ##-- get parameters: encodings | ||
| 132 | #my $enc = $h->getEncoding(@$vars{qw(encoding enc)},$hreq,$h->{encoding}); | ||
| 133 | #return $h->cerror($c, undef, "unknown encoding '$enc'") if (!defined(Encode::find_encoding($enc))); | ||
| 134 | |||
| 135 | ##-- pre-process query parameters | ||
| 136 | $h->decodeVars($vars, vars=>[qw(q a format fmt ifmt ofmt)], allowHtmlEscapes=>0); | ||
| 137 | $h->trimVars($vars, vars=>[qw(q a format fmt ifmt ofmt)]); | ||
| 138 | |||
| 139 | ##-- get analyzer $a | ||
| 140 | my $akey = $vars->{'a'} || $h->{defaultAnalyzer}; | ||
| 141 | $akey =~ s/^\Q$h->{prefix}\E// if (defined($h->{prefix})); ##-- trim leading prefix | ||
| 142 | if ($h->{allowAnalyzers} && !$h->{allowAnalyzers}{$akey}) { | ||
| 143 | return $h->cerror($c, RC_FORBIDDEN, "access denied for analyzer '$akey'"); | ||
| 144 | } | ||
| 145 | elsif (!defined($a=$srv->{as}{$akey})) { | ||
| 146 | return $h->cerror($c, RC_NOT_FOUND, "unknown analyzer '$akey'"); | ||
| 147 | } | ||
| 148 | |||
| 149 | ##-- get analyzer options | ||
| 150 | my %ao = $srv->{aos}{$akey} ? %{$srv->{aos}{$akey}} : qw(); | ||
| 151 | if ($h->{allowUserOptions}) { | ||
| 152 | foreach (grep {!exists $localParams{$_}} keys %$vars) { | ||
| 153 | $ao{$_} = $vars->{$_}; | ||
| 154 | } | ||
| 155 | } | ||
| 156 | $ao{doAnalyzeClean}=1 if ($vars->{clean} || $h->{forceClean}); | ||
| 157 | |||
| 158 | ##-- get format class(es) | ||
| 159 | $vars->{fmt} = $vars->{format} || $vars->{fmt} || $h->{defaultFormat}; | ||
| 160 | $vars->{ifmt} ||= $vars->{fmt}; | ||
| 161 | $vars->{ofmt} ||= $vars->{ifmt}; | ||
| 162 | my $fc = $vars->{format} || $vars->{fmt} || $h->{defaultFormat}; | ||
| 163 | my $ifc = $vars->{ifmt} || $fc; | ||
| 164 | my $ofc = $vars->{ofmt} || $ifc; | ||
| 165 | my $ifmt = $h->{formats}->newFormat($ifc, level=>($vars->{pretty}//0)) | ||
| 166 | or return $h->cerror($c, undef, "unknown input format '$ifc'"); | ||
| 167 | my $ofmt = ($ofc eq $ifc ? $ifmt : $h->{formats}->newFormat($ofc, level=>($vars->{pretty}//0))) | ||
| 168 | or return $h->cerror($c, undef, "unknown output format '$ofc'"); | ||
| 169 | |||
| 170 | ##-- parse input query | ||
| 171 | my ($qdoc); | ||
| 172 | if (defined($vars->{q})) { | ||
| 173 | ##-- raw untokenized query document | ||
| 174 | my $qsrc = defined($vars->{q}) ? $vars->{q} : ''; | ||
| 175 | $qsrc = join("\n", @$qsrc) if (ref($qsrc)); | ||
| 176 | my $qfmt = $h->{formats}->newFormat('raw') | ||
| 177 | or return $h->cerror($c, undef, "cannot create 'raw' format for query parameter 'q'"); | ||
| 178 | $qdoc = $qfmt->parseString(\$vars->{q}) | ||
| 179 | or $qfmt->logwarn("parseString() failed for raw query parameter 'q'"); | ||
| 180 | $qdoc->{textbufr} = \$vars->{q}; | ||
| 181 | } | ||
| 182 | elsif (defined($vars->{qd})) { | ||
| 183 | ##-- pre-tokenized query document | ||
| 184 | $qdoc = $ifmt->parseString(\$vars->{qd}) | ||
| 185 | or $ifmt->logwarn("parseString() failed for query parameter 'qd' via format '$fc'"); | ||
| 186 | } | ||
| 187 | else { | ||
| 188 | return $h->cerror($c, undef, "no query specified: use either the 'q' or 'qd' parameter!"); | ||
| 189 | } | ||
| 190 | return $h->cerror($c, undef, "could not parse input query: $@") if (!$qdoc); | ||
| 191 | |||
| 192 | ##-- analyze | ||
| 193 | $qdoc = $a->analyzeDocument($qdoc, \%ao) | ||
| 194 | or return $h->cerror($c, undef, "analyzeDocument() failed"); | ||
| 195 | |||
| 196 | ##-- format | ||
| 197 | my ($rstr); | ||
| 198 | $ofmt->flush->toString(\$rstr)->putDocument($qdoc)->flush; | ||
| 199 | utf8::encode($rstr) if (utf8::is_utf8($rstr)); | ||
| 200 | return $h->cerror($c, undef, "could not format output document using format '$ofc': $@") if (!defined($rstr)); | ||
| 201 | |||
| 202 | ##-- dump to client | ||
| 203 | my ($filename); | ||
| 204 | if (defined($filename=$vars->{file})) { | ||
| 205 | $filename =~ s/^.*[:\\\/]//; | ||
| 206 | } else { | ||
| 207 | $filename = $vars->{q} // 'data'; | ||
| 208 | $filename =~ s/\W.*$/_/; | ||
| 209 | } | ||
| 210 | $filename .= $ofmt->defaultExtension; | ||
| 211 | utf8::encode($filename) if (utf8::is_utf8($filename)); | ||
| 212 | return $h->dumpResponse(\$rstr, | ||
| 213 | raw=>$vars->{raw}, | ||
| 214 | type=>$ofmt->mimeType, | ||
| 215 | charset=>'UTF-8', | ||
| 216 | filename=>$filename); | ||
| 217 | } | ||
| 218 | |||
| 219 | ## $response = $h->runList($h,$srv,$path,$c,$hreq) | ||
| 220 | ## + guts for analyzer list | ||
| 221 | ## + accepted form parameters: | ||
| 222 | ## a => $regex ##-- regex of analyzers match | ||
| 223 | ## enc => $encoding, ##-- query/return encoding | ||
| 224 | ## fmt => $format, ##-- format to return list in | ||
| 225 | sub runList { | ||
| 226 | my ($h,$srv,$path,$c,$hreq) = @_; | ||
| 227 | |||
| 228 | ##-- check for LIST | ||
| 229 | #return $h->cerror($c,RC_NOT_FOUND,"/list path disabled") if (!$h->{allowList}); | ||
| 230 | |||
| 231 | ##-- parse list query parameters | ||
| 232 | my $vars = $h->cgiParams($c,$hreq) or return undef; | ||
| 233 | $h->vlog($h->{logVars}, "got query params:\n", Data::Dumper->Dump([$vars],['vars'])); | ||
| 234 | |||
| 235 | #my $enc = $h->getEncoding(@$vars{qw(enc encoding)},$hreq,$h->{encoding}); | ||
| 236 | #return $h->cerror($c, undef, "unknown encoding '$enc'") if (!defined(Encode::find_encoding($enc))); | ||
| 237 | |||
| 238 | $h->decodeVars($vars, vars=>[qw(a fmt format)], allowHtmlEscapes=>0); | ||
| 239 | $h->trimVars($vars, vars=>[qw(a fmt format)]); | ||
| 240 | |||
| 241 | ##-- get matching analyzers | ||
| 242 | my $qre = defined($vars->{a}) ? qr/$vars->{a}/ : qr//; | ||
| 243 | my @as = (grep {$_ =~ $qre} | ||
| 244 | grep {!defined($h->{allowAnalyzers}) || $h->{allowAnalyzers}{$_}} | ||
| 245 | sort | ||
| 246 | #map {($_,defined($h->{prefix}) ? "$h->{prefix}$_" : qw())} | ||
| 247 | keys %{$srv->{as}}); | ||
| 248 | |||
| 249 | ##-- get format | ||
| 250 | my $fc = $vars->{format} || $vars->{fmt} || $h->{defaultFormat}; | ||
| 251 | my $fmt = $h->{formats}->newFormat($fc,level=>$vars->{pretty}) | ||
| 252 | or return $h->cerror($c, undef, "unknown format '$fc': $@"); | ||
| 253 | |||
| 254 | ##-- dump analyzers | ||
| 255 | $fmt->{raw} = 1; ##-- hack to allow format dump of raw (non-document) data | ||
| 256 | my ($ostr); | ||
| 257 | if ($fmt->isa('DTA::CAB::Format::TT')) { | ||
| 258 | $ostr = join("\n", @as,''); | ||
| 259 | } | ||
| 260 | elsif ($fmt->isa('DTA::CAB::Format::XmlNative')) { | ||
| 261 | $fmt->{arrayEltKeys}{tokens} = 'a'; | ||
| 262 | $fmt->{key2xml}{text} = 'name'; | ||
| 263 | $fmt->toString(\$ostr)->putDocument({tokens=>[map {{text=>$_}} @as]}); | ||
| 264 | my $odoc = $fmt->xmlDocument; | ||
| 265 | $odoc->documentElement->setNodeName('analyzers'); | ||
| 266 | ## | ||
| 267 | $ostr = $odoc->toString($fmt->{level}||0); | ||
| 268 | } | ||
| 269 | else { | ||
| 270 | $fmt->toString(\$ostr)->putData(\@as)->flush; | ||
| 271 | } | ||
| 272 | utf8::encode($ostr) if (utf8::is_utf8($ostr)); | ||
| 273 | |||
| 274 | ##-- dump response | ||
| 275 | return $h->dumpResponse(\$ostr, | ||
| 276 | raw=>$vars->{raw}, | ||
| 277 | type=>$fmt->mimeType, | ||
| 278 | charset=>'UTF-8', | ||
| 279 | filename=>("analyzers".$fmt->defaultExtension), | ||
| 280 | ); | ||
| 281 | } | ||
| 282 | |||
| 283 | ##-------------------------------------------------------------- | ||
| 284 | ## Methods: Local | ||
| 285 | |||
| 286 | 1; ##-- be happy | ||
| 287 | |||
| 288 | __END__ |