CAB/Server/HTTP/Handler/Query.pm untested

filter: Statementstmt 0.0% 0 / 125 Branchbran 0.0% 0 / 52 Conditioncond 0.0% 0 / 80 MC/DCmcdc 0.0% 0 / 46 Subroutinesub 0.0% 0 / 11 Podpod 0.0% 0 / 5 totaltotal 0.0% 0 / 319 CC 27 SCAR 57.2
CC
27
Cov
0%
run
506.0
runList
30.0
prepare
6.0
CRAP 305.7
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__