755 lines
29 KiB
Python
755 lines
29 KiB
Python
#!/usr/bin/env python
|
|
|
|
# This file should be available from
|
|
# http://www.pobox.com/~asl2/software/PyZ3950/
|
|
# and is licensed under the X Consortium license:
|
|
# Copyright (c) 2001, Aaron S. Lav, asl2@pobox.com
|
|
# All rights reserved.
|
|
|
|
# Permission is hereby granted, free of charge, to any person obtaining a
|
|
# copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
# distribute, and/or sell copies of the Software, and to permit persons
|
|
# to whom the Software is furnished to do so, provided that the above
|
|
# copyright notice(s) and this permission notice appear in all copies of
|
|
# the Software and that both the above copyright notice(s) and this
|
|
# permission notice appear in supporting documentation.
|
|
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
|
# OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
# HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
|
# INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
|
# FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
|
# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
|
# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
# Except as contained in this notice, the name of a copyright holder
|
|
# shall not be used in advertising or otherwise to promote the sale, use
|
|
# or other dealings in this Software without prior written authorization
|
|
# of the copyright holder.
|
|
|
|
# Change history:
|
|
# 2002/05/23
|
|
# Fix for Python2 compatibility. Thanks to Douglas Bates <bates@stat.wisc.edu>
|
|
# Fix to support SUTRS (requires asn1 updates, too)
|
|
# 2002/05/28
|
|
# Make SUTRS printing a little more useful
|
|
# Correctly close connection when done
|
|
# Handle receiving diagnostics instead of records a little better
|
|
|
|
"""<p>PyZ3950 currently is capable of sending and receiving v2 or v3 PDUs
|
|
Initialize, Search, Present, Scan, Sort, Close, and Delete. For client
|
|
work, you probably want to use ZOOM, which should be in the same
|
|
distribution as this file, in zoom.py. The Server class in this file
|
|
implements a server, but could use some work. Both interoperate with
|
|
the <a href="http://www.indexdata.dk/yaz"> Yaz toolkit</a> and the
|
|
client interoperates with a variety of libraries. <p>
|
|
|
|
Useful resources:
|
|
<ul>
|
|
<li><a href="http://lcweb.loc.gov/z3950/agency/">
|
|
Library of Congress Z39.50 Maintenance Agency Page</a></li>
|
|
<li><a href="http://lcweb.loc.gov/z3950/agency/document.html">
|
|
Official Specification</a></li>
|
|
<li><a href="http://www.loc.gov/z3950/agency/clarify/">Clarifications</a></li>
|
|
</ul>
|
|
"""
|
|
|
|
from __future__ import nested_scopes
|
|
import getopt
|
|
import sys
|
|
import exceptions
|
|
import random
|
|
import socket
|
|
import string
|
|
import traceback
|
|
|
|
import codecs
|
|
|
|
from PyZ3950 import asn1
|
|
from PyZ3950 import zmarc
|
|
from PyZ3950.zdefs import *
|
|
|
|
out_encoding = None
|
|
|
|
trace_recv = 0
|
|
trace_init = 0
|
|
|
|
print_hex = 0
|
|
|
|
class Z3950Error(Exception):
|
|
pass
|
|
|
|
# Note: following 3 exceptions are defaults, but can be changed by
|
|
# calling conn.set_exs
|
|
|
|
class ConnectionError(Z3950Error): # TCP or other transport error
|
|
pass
|
|
|
|
class ProtocolError(Z3950Error): # Unexpected message or badly formatted
|
|
pass
|
|
|
|
class UnexpectedCloseError(ProtocolError):
|
|
pass
|
|
|
|
vers = '0.62'
|
|
default_resultSetName = 'default'
|
|
|
|
|
|
DEFAULT_PORT = 2101
|
|
|
|
Z3950_VERS = 3 # This is a global switch: do we support V3 at all?
|
|
|
|
def extract_recs (resp):
|
|
(typ, recs) = resp.records
|
|
if (typ <> 'responseRecords'):
|
|
raise ProtocolError ("Bad records typ " + str (typ) + str (recs))
|
|
if len (recs) == 0:
|
|
raise ProtocolError ("No records")
|
|
fmtoid = None
|
|
extract = []
|
|
for r in recs:
|
|
(typ, data) = r.record
|
|
if (typ <> 'retrievalRecord'):
|
|
raise ProtocolError ("Bad typ %s data %s" % (str (typ), str(data)))
|
|
oid = data.direct_reference
|
|
if fmtoid == None:
|
|
fmtoid = oid
|
|
elif fmtoid <> oid:
|
|
raise ProtocolError (
|
|
"Differing OIDs %s %s" % (str (fmtoid), str (oid)))
|
|
# Not, strictly speaking, an error.
|
|
dat = data.encoding
|
|
(typ, dat) = dat
|
|
if (oid == Z3950_RECSYN_USMARC_ov):
|
|
if typ <> 'octet-aligned':
|
|
raise ProtocolError ("Weird record EXTERNAL MARC type: " + typ)
|
|
extract.append (dat)
|
|
return (fmtoid, extract)
|
|
|
|
def get_formatter (oid):
|
|
def printer (x):
|
|
print oid, repr (x)
|
|
def print_marc (marc):
|
|
print str (zmarc.MARC(marc))
|
|
def print_sutrs (x):
|
|
print "SUTRS:",
|
|
if isinstance (x, type ('')):
|
|
print x
|
|
elif isinstance (x, type (u'')):
|
|
if out_encoding == None:
|
|
print repr (x)
|
|
else:
|
|
try:
|
|
print x.encode (out_encoding)
|
|
except UnicodeError, u:
|
|
print "Cannot print %s in current encoding %s" % (
|
|
repr (x), out_encoding)
|
|
if oid == Z3950_RECSYN_SUTRS_ov:
|
|
return print_sutrs
|
|
if oid == Z3950_RECSYN_USMARC_ov:
|
|
return print_marc
|
|
else:
|
|
return printer
|
|
|
|
def disp_resp (resp):
|
|
try:
|
|
(fmtoid, recs) = extract_recs (resp)
|
|
except ProtocolError, val:
|
|
print "Bad records", str (val)
|
|
formatter = get_formatter (fmtoid)
|
|
for rec in recs:
|
|
formatter (rec)
|
|
|
|
class Conn:
|
|
rdsz = 65536
|
|
def __init__ (self, sock = None, ConnectionError = ConnectionError,
|
|
ProtocolError = ProtocolError, UnexpectedCloseError =
|
|
UnexpectedCloseError):
|
|
self.set_exns (ConnectionError, ProtocolError, UnexpectedCloseError)
|
|
if sock == None:
|
|
self.sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
|
|
else:
|
|
self.sock = sock
|
|
self.decode_ctx = asn1.IncrementalDecodeCtx (APDU)
|
|
self.encode_ctx = asn1.Ctx ()
|
|
def set_exns (self, conn, protocol, unexp_close):
|
|
self.ConnectionError = conn
|
|
self.ProtocolError = protocol
|
|
self.UnexpectedCloseError = unexp_close
|
|
|
|
def set_codec (self, charset_name, charsets_in_records):
|
|
self.charset_name = charset_name
|
|
self.charsets_in_records = not not charsets_in_records # collapse None and 0
|
|
if trace_charset:
|
|
print "Setting up codec!", self.charset_name
|
|
strip_bom = self.charset_name == 'utf-16'
|
|
# XXX should create a new codec which wraps utf-16 but
|
|
# strips the Byte Order Mark, or use stream codecs
|
|
if self.charset_name <> None:
|
|
self.encode_ctx.set_codec (asn1.GeneralString,
|
|
codecs.lookup (self.charset_name),
|
|
strip_bom)
|
|
self.decode_ctx.set_codec (asn1.GeneralString,
|
|
codecs.lookup (self.charset_name),
|
|
strip_bom)
|
|
if not charsets_in_records: # None or 0
|
|
register_retrieval_record_oids(self.decode_ctx)
|
|
register_retrieval_record_oids(self.encode_ctx)
|
|
|
|
def readproc (self):
|
|
if self.sock == None:
|
|
raise self.ConnectionError ('disconnected')
|
|
try:
|
|
b = self.sock.recv (self.rdsz)
|
|
except socket.error, val:
|
|
self.sock = None
|
|
raise self.ConnectionError ('socket', str (val))
|
|
if len (b) == 0: # graceful close
|
|
self.sock = None
|
|
raise self.ConnectionError ('graceful close')
|
|
if trace_recv:
|
|
print map (lambda x: hex(ord(x)), b)
|
|
return b
|
|
def read_PDU (self):
|
|
while 1:
|
|
if self.decode_ctx.val_count () > 0:
|
|
return self.decode_ctx.get_first_decoded ()
|
|
try:
|
|
b = self.readproc ()
|
|
self.decode_ctx.feed (map (ord, b))
|
|
except asn1.BERError, val:
|
|
raise self.ProtocolError ('ASN1 BER', str(val))
|
|
|
|
|
|
class Server (Conn):
|
|
test = 0
|
|
def __init__ (self, sock):
|
|
Conn.__init__ (self, sock)
|
|
self.expecting_init = 1
|
|
self.done = 0
|
|
self.result_sets = {}
|
|
self.charset_name = None
|
|
def run (self):
|
|
while not self.done:
|
|
(typ, val) = self.read_PDU ()
|
|
fn = self.fn_dict.get (typ, None)
|
|
if fn == None:
|
|
raise self.ProtocolError ("Bad typ", typ + " " + str (val))
|
|
if typ <> 'initRequest' and self.expecting_init:
|
|
raise self.ProtocolError ("Init expected", typ)
|
|
fn (self, val)
|
|
def send (self, val):
|
|
b = self.encode_ctx.encode (APDU, val)
|
|
if self.test:
|
|
print "Internal Testing"
|
|
# a reminder not to leave this switched on by accident
|
|
self.decode_ctx.feed (b)
|
|
decoded = self.read_PDU ()
|
|
assert (val== decoded)
|
|
self.sock.send (b)
|
|
|
|
def do_close (self, reason, info):
|
|
close = Close ()
|
|
close.closeReason = reason
|
|
close.diagnosticInformation = info
|
|
self.send (('close', close))
|
|
|
|
def close (self, parm):
|
|
self.done = 1
|
|
self.do_close (0, 'Normal close')
|
|
|
|
def search_child (self, query):
|
|
return range (random.randint (2,10))
|
|
def search (self, sreq):
|
|
if sreq.replaceIndicator == 0 and self.result_sets.has_key (
|
|
sreq.resultSetName):
|
|
raise self.ProtocolError ("replaceIndicator 0")
|
|
result = self.search_child (sreq.query)
|
|
sresp = SearchResponse ()
|
|
self.result_sets[sreq.resultSetName] = result
|
|
sresp.resultCount = len (result)
|
|
sresp.numberOfRecordsReturned = 0
|
|
sresp.nextResultSetPosition = 1
|
|
sresp.searchStatus = 1
|
|
sresp.resultSetStatus = 0
|
|
sresp.presentStatus = PresentStatus.get_num_from_name ('success')
|
|
sresp.records = ('responseRecords', [])
|
|
self.send (('searchResponse', sresp))
|
|
def format_records (self, start, count, res_set, prefsyn):
|
|
l = []
|
|
for i in range (start - 1, start + count - 1):
|
|
elt = res_set[i]
|
|
elt_external = asn1.EXTERNAL ()
|
|
elt_external.direct_reference = Z3950_RECSYN_SUTRS_ov
|
|
|
|
# Not only has this text been extensively translated, but
|
|
# it also prefigures Z39.50's separation of Search and Present,
|
|
# once rearranged a little.
|
|
strings = [
|
|
'seek, and ye shall find; ask, and it shall be given you',
|
|
u"""Car quiconque demande re\u00e7oit, qui cherche trouve, et \u00e0 quit frappe on ouvrira""", # This (next) verse has non-ASCII characters
|
|
u"\u0391\u03b9\u03c4\u03b5\u03b9\u03c4\u03b5, "
|
|
u"\u03ba\u03b1\u03b9 \u03b4\u03bf\u03b8\u03b7\u03c3\u03b5\u03c4\u03b1\u03b9 "+
|
|
u"\u03c5\u03bc\u03b9\u03bd; \u03b6\u03b7\u03c4\u03b5\u03b9\u03c4\u03b5 " +
|
|
u"\u03ba\u03b1\u03b9 \u03b5\u03c5\u03c1\u03b7\u03c3\u03b5\u03c4\u03b5",
|
|
u"\u05e8\u05d0\u05d4 \u05d6\u05d4 \u05de\u05e6\u05d0\u05ea\u05d9"]
|
|
if self.charsets_in_records:
|
|
encode_charset = self.charset_name
|
|
else:
|
|
encode_charset = 'ascii'
|
|
def can_encode (s):
|
|
try:
|
|
s.encode (encode_charset)
|
|
except UnicodeError:
|
|
return 0
|
|
return 1
|
|
if self.charset_name == None:
|
|
candidate_strings = [strings[0]]
|
|
else:
|
|
candidate_strings = [s for s in strings if can_encode (s)]
|
|
# Note: this code is for debugging/testing purposes. Usually,
|
|
# language/content selection should not be made on the
|
|
# basis of the selected charset, and a surrogate diagnostic
|
|
# should be generated if the data cannot be encoded.
|
|
text = random.choice (candidate_strings)
|
|
add_str = " #%d charset %s cir %d" % (elt, encode_charset,
|
|
self.charsets_in_records)
|
|
elt_external.encoding = ('single-ASN1-type', text + add_str)
|
|
n = NamePlusRecord ()
|
|
n.name = 'foo'
|
|
n.record = ('retrievalRecord', elt_external)
|
|
l.append (n)
|
|
return l
|
|
|
|
def present (self, preq):
|
|
presp = PresentResponse ()
|
|
res_set = self.result_sets [preq.resultSetId]
|
|
presp.numberOfRecordsReturned = preq.numberOfRecordsRequested
|
|
presp.nextResultSetPosition = preq.resultSetStartPoint + \
|
|
preq.numberOfRecordsRequested
|
|
presp.presentStatus = 0
|
|
presp.records = ('responseRecords',
|
|
self.format_records (preq.resultSetStartPoint,
|
|
preq.numberOfRecordsRequested,
|
|
res_set,
|
|
preq.preferredRecordSyntax))
|
|
self.send (('presentResponse', presp))
|
|
|
|
def init (self, ireq):
|
|
if trace_init:
|
|
print "Init received", ireq
|
|
self.v3_flag = (ireq.protocolVersion ['version_3'] and
|
|
Z3950_VERS == 3)
|
|
|
|
ir = InitializeResponse ()
|
|
ir.protocolVersion = ProtocolVersion ()
|
|
ir.protocolVersion ['version_1'] = 1
|
|
ir.protocolVersion ['version_2'] = 1
|
|
ir.protocolVersion ['version_3'] = self.v3_flag
|
|
val = get_charset_negot (ireq)
|
|
charset_name = None
|
|
records_in_charsets = 0
|
|
if val <> None:
|
|
csreq = CharsetNegotReq ()
|
|
csreq.unpack_proposal (val)
|
|
def rand_choose (list_or_none):
|
|
if list_or_none == None or len (list_or_none) == 0:
|
|
return None
|
|
return random.choice (list_or_none)
|
|
charset_name = rand_choose (csreq.charset_list)
|
|
if charset_name <> None:
|
|
try:
|
|
codecs.lookup (charset_name)
|
|
except LookupError, l:
|
|
charset_name = None
|
|
csresp = CharsetNegotResp (
|
|
charset_name,
|
|
rand_choose (csreq.lang_list),
|
|
csreq.records_in_charsets)
|
|
records_in_charsets = csresp.records_in_charsets
|
|
if trace_charset:
|
|
print csreq, csresp
|
|
set_charset_negot (ir, csresp.pack_negot_resp (), self.v3_flag)
|
|
|
|
optionslist = ['search', 'present', 'delSet', 'scan','negotiation']
|
|
ir.options = Options ()
|
|
for o in optionslist:
|
|
ir.options[o] = 1
|
|
|
|
ir.preferredMessageSize = 0
|
|
|
|
ir.exceptionalRecordSize = 0
|
|
# z9350-2001 3.2.1.1.4, 0 means client should be prepared to accept
|
|
# arbitrarily long messages.
|
|
|
|
ir.implementationId = implementationId
|
|
|
|
ir.implementationName = 'PyZ3950 Test server'
|
|
ir.implementationVersion = impl_vers
|
|
ir.result = 1
|
|
|
|
if trace_charset or trace_init:
|
|
print ir
|
|
self.expecting_init = 0
|
|
self.send (('initResponse', ir))
|
|
self.set_codec (charset_name, records_in_charsets)
|
|
|
|
def sort (self, sreq):
|
|
sresp = SortResponse ()
|
|
sresp.sortStatus = 0
|
|
self.send (('sortResponse', sresp))
|
|
def delete (self, dreq):
|
|
dresp = DeleteResultSetResponse ()
|
|
dresp.deleteOperationStatus = 0
|
|
self.send (('deleteResultSetResponse', dresp))
|
|
def esrequest (self, esreq):
|
|
print "ES", esreq
|
|
esresp = ExtendedServicesResponse ()
|
|
esresp.operationStatus = ExtendedServicesResponse['operationStatus'].get_num_from_name ('failure')
|
|
self.send (('extendedServicesResponse', esresp))
|
|
|
|
fn_dict = {'searchRequest': search,
|
|
'presentRequest': present,
|
|
'initRequest' : init,
|
|
'close' : close,
|
|
'sortRequest' : sort,
|
|
'deleteResultSetRequest' : delete,
|
|
'extendedServicesRequest': esrequest}
|
|
|
|
|
|
def run_server (test = 0):
|
|
listen = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
|
|
listen.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
listen.bind (('', DEFAULT_PORT))
|
|
listen.listen (1)
|
|
while 1:
|
|
(sock,addr) = listen.accept ()
|
|
try:
|
|
serv = Server (sock)
|
|
serv.test = test
|
|
serv.run ()
|
|
except:
|
|
(typ, val, tb) = sys.exc_info ()
|
|
if typ == exceptions.KeyboardInterrupt:
|
|
print "kbd interrupt, leaving"
|
|
raise
|
|
print "error %s %s from %s" % (typ, val, addr)
|
|
traceback.print_exc(40)
|
|
sock.close ()
|
|
|
|
def extract_apt (rpnQuery):
|
|
"""Takes RPNQuery to AttributePlusTerm"""
|
|
RPNStruct = rpnQuery.rpn
|
|
assert (RPNStruct [0] == 'op')
|
|
operand = RPNStruct [1]
|
|
assert (operand [0] == 'attrTerm')
|
|
return operand [1]
|
|
|
|
|
|
class Client (Conn):
|
|
test = 0
|
|
|
|
def __init__ (self, addr, port = DEFAULT_PORT, optionslist = None,
|
|
charset = None, lang = None, user = None, password = None,
|
|
preferredMessageSize = 0x100000, group = None,
|
|
maximumRecordSize = 0x100000, implementationId = "",
|
|
implementationName = "", implementationVersion = "",
|
|
ConnectionError = ConnectionError,
|
|
ProtocolError = ProtocolError,
|
|
UnexpectedCloseError = UnexpectedCloseError):
|
|
|
|
Conn.__init__ (self, ConnectionError = ConnectionError,
|
|
ProtocolError = ProtocolError,
|
|
UnexpectedCloseError = UnexpectedCloseError)
|
|
try:
|
|
self.sock.connect ((addr, port))
|
|
except socket.error, val:
|
|
self.sock = None
|
|
raise self.ConnectionError ('socket', str(val))
|
|
try_v3 = Z3950_VERS == 3
|
|
|
|
if (charset and not isinstance(charset, list)):
|
|
charset = [charset]
|
|
if (lang and not isinstance(lang, list)):
|
|
charset = [lang]
|
|
negotiate_charset = charset or lang
|
|
|
|
if (user or password or group):
|
|
authentication = (user, password, group)
|
|
else:
|
|
authentication = None
|
|
|
|
InitReq = make_initreq (optionslist, authentication = authentication,
|
|
v3 = try_v3,
|
|
preferredMessageSize = preferredMessageSize,
|
|
maximumRecordSize = maximumRecordSize,
|
|
implementationId = implementationId,
|
|
implementationName = implementationName,
|
|
implementationVersion = implementationVersion,
|
|
negotiate_charset = negotiate_charset)
|
|
if negotiate_charset:
|
|
# languages = ['eng', 'fre', 'enm']
|
|
# Thanne longen folk to looken in catalogues
|
|
# and clerkes for to seken straunge bookes ...
|
|
cnr = CharsetNegotReq (charset, lang, random.choice((0,1,None)))
|
|
if trace_charset:
|
|
print cnr
|
|
set_charset_negot (InitReq, cnr.pack_proposal (), try_v3)
|
|
|
|
if trace_init:
|
|
print "Initialize request", InitReq
|
|
|
|
self.initresp = self.transact (
|
|
('initRequest', InitReq), 'initResponse')
|
|
if trace_init:
|
|
print "Initialize Response", self.initresp
|
|
self.v3_flag = self.initresp.protocolVersion ['version_3']
|
|
val = get_charset_negot (self.initresp)
|
|
if val <> None:
|
|
csr = CharsetNegotResp ()
|
|
csr.unpack_negot_resp (val)
|
|
if trace_charset:
|
|
print "Got csr", str (csr)
|
|
self.set_codec (csr.charset, csr.records_in_charsets)
|
|
|
|
self.search_results = {}
|
|
self.max_to_request = 20
|
|
self.default_recordSyntax = Z3950_RECSYN_USMARC_ov
|
|
def get_option (self, option_name):
|
|
return self.initresp.options[option_name]
|
|
def transact (self, to_send, expected):
|
|
b = self.encode_ctx.encode (APDU, to_send)
|
|
if print_hex:
|
|
print map (hex, b)
|
|
if self.test:
|
|
print "Internal Testing"
|
|
# a reminder not to leave this switched on by accident
|
|
self.decode_ctx.feed (b)
|
|
decoded = self.read_PDU ()
|
|
print "to_send", to_send, "decoded", decoded
|
|
assert (to_send == decoded)
|
|
if self.sock == None:
|
|
raise self.ConnectionError ('disconnected')
|
|
try:
|
|
self.sock.send (b)
|
|
except socket.error, val:
|
|
self.sock = None
|
|
raise self.ConnectionError('socket', str(val))
|
|
|
|
if expected == None:
|
|
return
|
|
pdu = self.read_PDU ()
|
|
(arm, val) = pdu
|
|
if self.test:
|
|
print "Internal Testing 2"
|
|
b = self.encode_ctx.encode (APDU, (arm, val))
|
|
self.decode_ctx.feed (b)
|
|
redecoded = self.read_PDU ()
|
|
if redecoded <> (arm, val):
|
|
print "Redecoded", redecoded
|
|
print "old", (arm, val)
|
|
assert (redecoded == (arm, val))
|
|
if arm == expected: # may be 'close'
|
|
return val
|
|
elif arm == 'close':
|
|
raise self.UnexpectedCloseError (
|
|
"Server closed connection reason %d diag info %s" % \
|
|
(getattr (val, 'closeReason', -1),
|
|
getattr (val, 'diagnosticInformation', 'None given')))
|
|
else:
|
|
raise self.ProtocolError (
|
|
"Unexpected response from server %s %s " % (expected,
|
|
repr ((arm, val))))
|
|
def set_dbnames (self, dbnames):
|
|
self.dbnames = dbnames
|
|
def search_2 (self, query, rsn = default_resultSetName, **kw):
|
|
# We used to check self.initresp.options['search'], but
|
|
# support for search is required by the standard, and
|
|
# www.cnshb.ru:210 doesn't set the search bit if you negotiate
|
|
# v2, but supports search anyway
|
|
sreq = make_sreq (query, self.dbnames, rsn, **kw)
|
|
recv = self.transact (('searchRequest', sreq), 'searchResponse')
|
|
self.search_results [rsn] = recv
|
|
return recv
|
|
def search (self, query, rsn = default_resultSetName, **kw):
|
|
# for backwards compat
|
|
recv = self.search_2 (('type_1', query), rsn, **kw)
|
|
return recv.searchStatus and (recv.resultCount > 0)
|
|
# If searchStatus is failure, check result-set-status -
|
|
# -subset - partial, valid results available
|
|
# -interim - partial, not necessarily valid
|
|
# -none - no result set
|
|
# If searchStatus is success, check present-status:
|
|
# - success - OK
|
|
# - partial-1 - not all, access control
|
|
# - partial-2 - not all, won't fit in msg size (but we currently don't ask for
|
|
# any records in search, shouldn't happen)
|
|
# - partial-3 - not all, resource control (origin)
|
|
# - partial-4 - not all, resource control (target)
|
|
# - failure - no records, nonsurrogate diagnostic.
|
|
def get_count (self, rsn = default_resultSetName):
|
|
return self.search_results[rsn].resultCount
|
|
def delete (self, rsn):
|
|
if not self.initresp.options['delSet']:
|
|
return None
|
|
delreq = DeleteResultSetRequest ()
|
|
delreq.deleteFunction = 0 # list
|
|
delreq.resultSetList = [rsn]
|
|
return self.transact (('deleteResultSetRequest', delreq),
|
|
'deleteResultSetResponse')
|
|
def present (self, rsn= default_resultSetName, start = None,
|
|
count = None, recsyn = None, esn = None):
|
|
# don't check for support in init resp: see search for reasoning
|
|
|
|
# XXX Azaroth 2004-01-08. This does work when rs is result of sort.
|
|
try:
|
|
sresp = self.search_results [rsn]
|
|
if start == None:
|
|
start = sresp.nextResultSetPosition
|
|
if count == None:
|
|
count = sresp.resultCount
|
|
if self.max_to_request > 0:
|
|
count = min (self.max_to_request, count)
|
|
except:
|
|
pass
|
|
if recsyn == None:
|
|
recsyn = self.default_recordSyntax
|
|
preq = PresentRequest ()
|
|
preq.resultSetId = rsn
|
|
preq.resultSetStartPoint = start
|
|
preq.numberOfRecordsRequested = count
|
|
preq.preferredRecordSyntax = recsyn
|
|
if esn <> None:
|
|
preq.recordComposition = ('simple', esn)
|
|
return self.transact (('presentRequest', preq), 'presentResponse')
|
|
def scan (self, query, **kw):
|
|
sreq = ScanRequest ()
|
|
sreq.databaseNames = self.dbnames
|
|
assert (query[0] == 'type_1' or query [0] == 'type_101')
|
|
sreq.attributeSet = query[1].attributeSet
|
|
sreq.termListAndStartPoint = extract_apt (query[1])
|
|
sreq.numberOfTermsRequested = 20 # default
|
|
for (key, val) in kw.items ():
|
|
setattr (sreq, key, val)
|
|
|
|
return self.transact (('scanRequest', sreq), 'scanResponse')
|
|
def close (self):
|
|
close = Close ()
|
|
close.closeReason = 0
|
|
close.diagnosticInformation = 'Normal close'
|
|
try:
|
|
rv = self.transact (('close', close), 'close')
|
|
except self.ConnectionError:
|
|
rv = None
|
|
if self.sock <> None:
|
|
self.sock.close ()
|
|
self.sock = None
|
|
return rv
|
|
|
|
|
|
def mk_compound_query ():
|
|
aelt1 = AttributeElement (attributeType = 1,
|
|
attributeValue = ('numeric',4))
|
|
apt1 = AttributesPlusTerm ()
|
|
apt1.attributes = [aelt1]
|
|
apt1.term = ('general', '1066')
|
|
aelt2 = AttributeElement (attributeType = 1,
|
|
attributeValue = ('numeric', 1))
|
|
apt2 = AttributesPlusTerm ()
|
|
apt2.attributes = [aelt2]
|
|
apt2.term = ('general', 'Sellar')
|
|
myrpnRpnOp = RpnRpnOp ()
|
|
myrpnRpnOp.rpn1 = ('op', ('attrTerm', apt1))
|
|
myrpnRpnOp.rpn2 = ('op', ('attrTerm', apt2))
|
|
myrpnRpnOp.op = ('and', None)
|
|
rpnq = RPNQuery (attributeSet = Z3950_ATTRS_BIB1_ov)
|
|
rpnq.rpn = ('rpnRpnOp', myrpnRpnOp)
|
|
return rpnq
|
|
|
|
def mk_simple_query (title):
|
|
aelt1 = AttributeElement (attributeType = 1,
|
|
attributeValue = ('numeric', 1003))
|
|
apt1 = AttributesPlusTerm ()
|
|
apt1.attributes = [aelt1]
|
|
apt1.term = ('general', title) # XXX or should be characterString, not general, but only when V3.
|
|
rpnq = RPNQuery (attributeSet = Z3950_ATTRS_BIB1_ov)
|
|
rpnq.rpn = ('op', ('attrTerm', apt1))
|
|
return rpnq
|
|
|
|
def_host = 'LC'
|
|
|
|
host_dict = {'BIBSYS': ('z3950.bibsys.no', 2100, 'BIBSYS'),
|
|
'YAZ': ('127.0.0.1', 9999, 'foo'),
|
|
'LCTEST' : ('ilssun2.loc.gov', 7090, 'Voyager'),
|
|
'LC' : ('z3950.loc.gov', 7090, 'Voyager'),
|
|
'NLC' : ('amicus.nlc-bnc.ca', 210, 'NL'),
|
|
'BNC' : ('amicus.nlc-bnc.ca', 210, 'NL'),
|
|
# On parle franc,ais aussi.
|
|
'LOCAL': ('127.0.0.1', 9999, 'Default'),
|
|
'LOCAL2': ('127.0.0.1', 2101, 'foo'),
|
|
'BL' :('blpcz.bl.uk', 21021, 'BLPC-ALL'),
|
|
'BELLLABS' : ('z3950.bell-labs.com', 210, 'books'),
|
|
'BIBHIT' : ('www.bibhit.dk', 210, 'Default'),
|
|
'YALE': ('webpac.library.yale.edu', 210, 'YALEOPAC'),
|
|
'OXFORD': ('library.ox.ac.uk', 210, 'ADVANCE'),
|
|
'OVID': ('z3950.ovid.com', 2213, 'pmed'), # scan only
|
|
'UC': ('ipac.lib.uchicago.edu', 210, 'uofc'),
|
|
'KUB' : ('dbiref.kub.nl', 1800, 'jel'),
|
|
'INDEXDATA' : ('muffin.indexdata.dk', 9004, 'thatt')}
|
|
# last two are Zthes servers.
|
|
|
|
if __name__ == '__main__':
|
|
optlist, args = getopt.getopt (sys.argv[1:], 'e:sh:tc:l:')
|
|
server = 0
|
|
host = def_host
|
|
test = 0
|
|
charset_list = None
|
|
lang_list = None
|
|
for (opt, val) in optlist:
|
|
if opt == '-s':
|
|
server = 1
|
|
elif opt == '-h':
|
|
host = val
|
|
elif opt == '-t':
|
|
test = 1
|
|
elif opt == '-e':
|
|
out_encoding = val
|
|
elif opt == '-c':
|
|
charset_list = val.split (',')
|
|
elif opt == '-l':
|
|
lang_list = val.split (',')
|
|
if server:
|
|
run_server (test)
|
|
|
|
host = host.upper ()
|
|
(name, port, dbname) = host_dict.get (host, host_dict[def_host])
|
|
cli = Client (name, port, charset = charset_list,
|
|
lang = lang_list)
|
|
cli.test = test
|
|
cli.set_dbnames ([dbname])
|
|
print "Starting search"
|
|
# rpnq = mk_simple_query ('Perec, Georges')
|
|
# rpnq = mk_simple_query ('Johnson, Kim')
|
|
rpnq = mk_compound_query ()
|
|
if cli.search (rpnq, smallSetUpperBound = 0, mediumSetPresentNumber = 0,
|
|
largeSetLowerBound = 1):
|
|
disp_resp (cli.present (recsyn = Z3950_RECSYN_USMARC_ov))
|
|
else:
|
|
print "Not found"
|
|
print "Deleting"
|
|
cli.delete (default_resultSetName)
|
|
cli.delete ('bogus')
|
|
print "Closing"
|
|
try:
|
|
cli.close ()
|
|
except ConnectionError:
|
|
# looks like LC, at least, sends a FIN on receipt of Close PDU
|
|
# guess we should check for gracefullness of close, and complain
|
|
# if not.
|
|
pass
|
|
|