def kXR_verifyw(self,
streamid=None,
requestid=None,
fhandle=None,
offset=None,
pathid=None,
vertype=None,
reserved=None,
dlen=None,
data=None):
"""Return a packed representation of a kXR_verifyw request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientVerifywRequest')
if not data: data = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_verifyw'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'offset' : offset if offset else 0,
'pathid' : pathid if pathid else '\0',
'vertype' : vertype if vertype else '\0',
'reserved' : reserved if reserved else (2 * "\0"),
'dlen' : dlen if dlen else len(data),
'data' : data}
return self.mh.build_message(request_struct, params)
def kXR_readv(self,
streamid=None,
requestid=None,
reserved=None,
pathid=None,
dlen=None,
**read_lists):
"""Return a packed representation of a kXR_readv request. You can pass in
multiple read_lists with arbitrary keyword names, but they must have the
format (fhandle, rlen, offset)."""
all_read_lists = ''
for read_list in read_lists.itervalues():
read_struct = get_struct('ClientRequestHdr') + get_struct(
'readahead_list')
params = \
{'fhandle2': read_list[0] if read_list[0] else (4 * '\0'),
'rlen2' : read_list[1] if read_list[1] else 0,
'roffset2': read_list[2] if read_list[2] else 0}
all_read_lists += self.mh.build_message(read_struct, params)
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientReadVRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_readv'),
'reserved' : reserved if reserved else (15 * "\0"),
'pathid' : pathid if pathid else '0',
'dlen' : dlen if dlen else len(all_read_lists)}
return self.mh.build_message(request_struct, params) + all_read_lists
def kXR_read(self, streamid=None, requestid=None, fhandle=None, offset=None,
rlen=None, dlen=None, pathid=None, reserved=None,
readahead=False, fhandle2=None, rlen2=None, roffset2=None):
"""Return a packed representation of a kXR_read request. Pass
readahead=True to enable pre-read."""
read_args = get_struct('read_args')
params = \
{'pathid' : pathid if pathid else '',
'reserved' : reserved if reserved else (7 * '\0')}
read_args = self.mh.build_message(read_args, params)
if readahead:
readahead_list = get_struct('readahead_list')
params = \
{'fhandle2': fhandle2 if fhandle2 else (4 * '\0'),
'rlen2' : rlen2 if rlen2 else 0,
'roffset2': roffset2 if roffset2 else 0}
readahead_list = self.mh.build_message(readahead_list, params)
else: readahead_list = ''
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientReadRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_read'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'offset' : offset if offset else 0,
'rlen' : rlen if rlen else 0,
'dlen' : dlen if dlen else len(read_args
+ readahead_list)}
return self.mh.build_message(request_struct, params) \
+ read_args + readahead_list
def kXR_login(self,
streamid=None,
requestid=None,
pid=None,
username=None,
reserved=None,
zone=None,
capver=None,
role=None,
dlen=None):
"""Return a packed representation of a kXR_login request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientLoginRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_login'),
'pid' : pid if pid else os.getpid(),
'username' : username if username else ''.ljust(8, "\0"),
'reserved' : reserved if reserved else '\0',
'zone' : zone if zone else '\0',
'capver' : capver if capver else chr(XProtocol.XLoginCapVer
.kXR_asyncap \
| XProtocol.XLoginVersion
.kXR_ver003),
'role' : role if role else '0',
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_rmdir(self,
streamid=None,
requestid=None,
reserved=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_rmdir request."""
if not requestid: requestid = get_requestid('kXR_rmdir')
return self.kXR_rm(streamid, requestid, reserved, dlen, path)
def kXR_endsess(self, streamid=None, requestid=None, sessid=None, dlen=None):
"""Return a packed representation of a kXR_endsess request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientEndsessRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_endsess'),
'sessid' : sessid if sessid else (16 * '\0'),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_ping(self, streamid=None, requestid=None, reserved=None, dlen=None):
"""Return a packed representation of a kXR_ping request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientPingRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_ping'),
'reserved' : reserved if reserved else (16 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_bind(self, streamid=None, requestid=None, sessid=None, dlen=None):
"""Return a packed representation of a kXR_bind request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientBindRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_bind'),
'sessid' : sessid if sessid else gen_sessid(),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_statx(self,
streamid=None,
requestid=None,
reserved=None,
dlen=None,
paths=None):
"""Return a packed representation of a kXR_statx request."""
if not requestid: requestid = get_requestid('kXR_statx')
return self.kXR_stat(streamid, requestid, None, reserved, None, dlen,
path)
def kXR_sync(self, streamid=None, requestid=None, fhandle=None, reserved=None,
dlen=None, path=None):
"""Return a packed representation of a kXR_sync request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientSyncRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_sync'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_close(self, streamid=None, requestid=None, fhandle=None, fsize=None,
reserved=None, dlen=None):
"""Return a packed representation of a kXR_close request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientCloseRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_close'),
'fhandle' : fhandle if fhandle else (4 * '\0'),
'fsize' : fsize if fsize else 0,
'reserved' : reserved if reserved else (4 * '\0'),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_protocol(self, streamid=None, requestid=None, clientpv=None,
reserved=None, dlen=None):
"""Return a packed representation of a kXR_protocol request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientProtocolRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_protocol'),
'clientpv' : clientpv if clientpv else XProtocol.XLoginVersion
.kXR_ver003,
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_rm(self, streamid=None, requestid=None, reserved=None, dlen=None,
path=None):
"""Return a packed representation of a kXR_rm request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientRmRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_rm'),
'reserved' : reserved if reserved else (16 * '\0'),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_set(self, streamid=None, requestid=None, reserved=None, dlen=None,
data=None):
"""Return a packed representation of a kXR_set request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientSetRequest')
if not data: data = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_set'),
'reserved' : reserved if reserved else (16 * '\0'),
'dlen' : dlen if dlen else len(data),
'data' : data}
return self.mh.build_message(request_struct, params)
def unpack_request(self, request_raw):
"""Return an unpacked named tuple representation of a client request."""
if not len(request_raw): return
# Unpack the header to find the request ID
requestid = self.unpack('>HH' + (str(len(request_raw) - 4) + 's'),
request_raw)[1]
# Check if this is a handshake request
if requestid == XProtocol.XRequestTypes.handshake:
request_struct = get_struct('ClientInitHandShake')
else:
request_type = XProtocol.XRequestTypes.reverse_mapping[requestid]
request_struct = get_struct('ClientRequestHdr')
request_struct += get_struct('Client' + request_type[4:].title() +
'Request')
if requestid == XProtocol.XRequestTypes.kXR_read:
request_struct += get_struct('read_args')
# Check if another request is being piggybacked.
pending_req = None
if len(request_raw) > format_length(struct_format(request_struct)):
pending_req = request_raw[
format_length(struct_format(request_struct)):]
request_raw = request_raw[:format_length(
struct_format(request_struct))]
# Build the complete format string
format = '>'
for member in request_struct:
if member.has_key('size'):
if member['size'] == 'dlen':
format += str(len(request_raw) - format_length(format)) \
+ member['type']
else:
format += str(member['size']) + member['type']
else:
format += member['type']
# Unpack to a regular tuple
request_tuple = self.unpack(format, request_raw)
# Convert to named tuple
request_struct.insert(0, {'name': 'type'})
if requestid == XProtocol.XRequestTypes.handshake:
type = 'handshake'
else:
type = get_requestid(requestid)
request = namedtuple('request',
' '.join([m['name'] for m in request_struct]))
return request(type, *request_tuple), pending_req
def kXR_write(self,
streamid=None,
requestid=None,
fhandle=None,
offset=None,
pathid=None,
reserved=None,
dlen=None,
data=None):
"""Return a packed representation of a kXR_write request."""
if not requestid: requestid = get_requestid('kXR_write')
return self.kXR_verifyw(streamid, requestid, fhandle, offset, pathid,
None, reserved, dlen, data)
def unpack_request(self, request_raw):
"""Return an unpacked named tuple representation of a client request."""
if not len(request_raw): return
# Unpack the header to find the request ID
requestid = self.unpack('>HH' + (str(len(request_raw) - 4) + 's'),
request_raw)[1]
# Check if this is a handshake request
if requestid == XProtocol.XRequestTypes.handshake:
request_struct = get_struct('ClientInitHandShake')
else:
request_type = XProtocol.XRequestTypes.reverse_mapping[requestid]
request_struct = get_struct('ClientRequestHdr')
request_struct += get_struct('Client' + request_type[4:].title()
+ 'Request')
if requestid == XProtocol.XRequestTypes.kXR_read:
request_struct += get_struct('read_args')
# Check if another request is being piggybacked.
pending_req = None
if len(request_raw) > format_length(struct_format(request_struct)):
pending_req = request_raw[format_length(struct_format(request_struct)):]
request_raw = request_raw[:format_length(struct_format(request_struct))]
# Build the complete format string
format = '>'
for member in request_struct:
if member.has_key('size'):
if member['size'] == 'dlen':
format += str(len(request_raw) - format_length(format)) \
+ member['type']
else:
format += str(member['size']) + member['type']
else:
format += member['type']
# Unpack to a regular tuple
request_tuple = self.unpack(format, request_raw)
# Convert to named tuple
request_struct.insert(0, {'name': 'type'})
if requestid == XProtocol.XRequestTypes.handshake:
type = 'handshake'
else:
type = get_requestid(requestid)
request = namedtuple('request',
' '.join([m['name'] for m in request_struct]))
return request(type, *request_tuple), pending_req
def kXR_ping(self,
streamid=None,
requestid=None,
reserved=None,
dlen=None):
"""Return a packed representation of a kXR_ping request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientPingRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_ping'),
'reserved' : reserved if reserved else (16 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_stat(self, streamid=None, requestid=None, options=None, reserved=None,
fhandle=None, dlen=None, path=None):
"""Return a packed representation of a kXR_stat request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientStatRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_stat'),
'options' : options if options else '\0',
'reserved' : reserved if reserved else (11 * "\0"),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_truncate(self, streamid=None, requestid=None, fhandle=None,
size=None, reserved=None, dlen=None, path=None):
"""Return a packed representation of a kXR_truncate request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientTruncateRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_truncate'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'size' : size if size else 0,
'reserved' : reserved if reserved else (4 * "\0"),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_open(self, streamid=None, requestid=None, mode=None, options=None,
reserved=None, dlen=None, path=None):
"""Return a packed representation of a kXR_open request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientOpenRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_open'),
'mode' : mode if mode else 0,
'options' : options if options else 0,
'reserved' : reserved if reserved else (12 * '\0'),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_prepare(self, streamid=None, requestid=None, options=None, prty=None,
port=None, reserved=None, dlen=None, plist=None):
"""Return a packed representation of a kXR_prepare request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientPrepareRequest')
if not plist: plist = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_prepare'),
'options' : options if options else '\0',
'prty' : prty if prty else '\0',
'port' : port if port else 0,
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else len(plist),
'plist' : plist}
return self.mh.build_message(request_struct, params)
def kXR_query(self, streamid=None, requestid=None, reqcode=None,
reserved1=None, fhandle=None, reserved2=None, dlen=None,
args=None):
"""Return a packed representation of a kXR_query request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientQueryRequest')
if not args: args = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_query'),
'reqcode' : reqcode if reqcode else 0,
'reserved1' : reserved1 if reserved1 else (2 * "\0"),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'reserved2' : reserved2 if reserved2 else (8 * "\0"),
'dlen' : dlen if dlen else len(args),
'args' : args}
return self.mh.build_message(request_struct, params)
def kXR_rm(self,
streamid=None,
requestid=None,
reserved=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_rm request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientRmRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_rm'),
'reserved' : reserved if reserved else (16 * '\0'),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_set(self,
streamid=None,
requestid=None,
reserved=None,
dlen=None,
data=None):
"""Return a packed representation of a kXR_set request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientSetRequest')
if not data: data = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_set'),
'reserved' : reserved if reserved else (16 * '\0'),
'dlen' : dlen if dlen else len(data),
'data' : data}
return self.mh.build_message(request_struct, params)
def kXR_protocol(self,
streamid=None,
requestid=None,
clientpv=None,
reserved=None,
dlen=None):
"""Return a packed representation of a kXR_protocol request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientProtocolRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_protocol'),
'clientpv' : clientpv if clientpv else XProtocol.XLoginVersion
.kXR_ver003,
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_sync(self,
streamid=None,
requestid=None,
fhandle=None,
reserved=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_sync request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientSyncRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_sync'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_verifyw(self, streamid=None, requestid=None, fhandle=None,
offset=None, pathid=None, vertype=None, reserved=None,
dlen=None, data=None):
"""Return a packed representation of a kXR_verifyw request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientVerifywRequest')
if not data: data = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_verifyw'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'offset' : offset if offset else 0,
'pathid' : pathid if pathid else '\0',
'vertype' : vertype if vertype else '\0',
'reserved' : reserved if reserved else (2 * "\0"),
'dlen' : dlen if dlen else len(data),
'data' : data}
return self.mh.build_message(request_struct, params)
def kXR_close(self,
streamid=None,
requestid=None,
fhandle=None,
fsize=None,
reserved=None,
dlen=None):
"""Return a packed representation of a kXR_close request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientCloseRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_close'),
'fhandle' : fhandle if fhandle else (4 * '\0'),
'fsize' : fsize if fsize else 0,
'reserved' : reserved if reserved else (4 * '\0'),
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_read(self,
streamid=None,
requestid=None,
fhandle=None,
offset=None,
rlen=None,
dlen=None,
pathid=None,
reserved=None,
readahead=False,
fhandle2=None,
rlen2=None,
roffset2=None):
"""Return a packed representation of a kXR_read request. Pass
readahead=True to enable pre-read."""
read_args = get_struct('read_args')
params = \
{'pathid' : pathid if pathid else '',
'reserved' : reserved if reserved else (7 * '\0')}
read_args = self.mh.build_message(read_args, params)
if readahead:
readahead_list = get_struct('readahead_list')
params = \
{'fhandle2': fhandle2 if fhandle2 else (4 * '\0'),
'rlen2' : rlen2 if rlen2 else 0,
'roffset2': roffset2 if roffset2 else 0}
readahead_list = self.mh.build_message(readahead_list, params)
else:
readahead_list = ''
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientReadRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_read'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'offset' : offset if offset else 0,
'rlen' : rlen if rlen else 0,
'dlen' : dlen if dlen else len(read_args
+ readahead_list)}
return self.mh.build_message(request_struct, params) \
+ read_args + readahead_list
def kXR_login(self, streamid=None, requestid=None, pid=None, username=None,
reserved=None, zone=None, capver=None, role=None,
dlen=None):
"""Return a packed representation of a kXR_login request."""
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientLoginRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_login'),
'pid' : pid if pid else os.getpid(),
'username' : username if username else ''.ljust(8, "\0"),
'reserved' : reserved if reserved else '\0',
'zone' : zone if zone else '\0',
'capver' : capver if capver else chr(XProtocol.XLoginCapVer
.kXR_asyncap \
| XProtocol.XLoginVersion
.kXR_ver003),
'role' : role if role else '0',
'dlen' : dlen if dlen else 0}
return self.mh.build_message(request_struct, params)
def kXR_stat(self,
streamid=None,
requestid=None,
options=None,
reserved=None,
fhandle=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_stat request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientStatRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_stat'),
'options' : options if options else '\0',
'reserved' : reserved if reserved else (11 * "\0"),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_open(self,
streamid=None,
requestid=None,
mode=None,
options=None,
reserved=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_open request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientOpenRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_open'),
'mode' : mode if mode else 0,
'options' : options if options else 0,
'reserved' : reserved if reserved else (12 * '\0'),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_truncate(self,
streamid=None,
requestid=None,
fhandle=None,
size=None,
reserved=None,
dlen=None,
path=None):
"""Return a packed representation of a kXR_truncate request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientTruncateRequest')
if not path: path = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_truncate'),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'size' : size if size else 0,
'reserved' : reserved if reserved else (4 * "\0"),
'dlen' : dlen if dlen else len(path),
'path' : path}
return self.mh.build_message(request_struct, params)
def kXR_readv(self, streamid=None, requestid=None, reserved=None, pathid=None,
dlen=None, **read_lists):
"""Return a packed representation of a kXR_readv request. You can pass in
multiple read_lists with arbitrary keyword names, but they must have the
format (fhandle, rlen, offset)."""
all_read_lists = ''
for read_list in read_lists.itervalues():
read_struct = get_struct('ClientRequestHdr') + get_struct('readahead_list')
params = \
{'fhandle2': read_list[0] if read_list[0] else (4 * '\0'),
'rlen2' : read_list[1] if read_list[1] else 0,
'roffset2': read_list[2] if read_list[2] else 0}
all_read_lists += self.mh.build_message(read_struct, params)
request_struct = get_struct('ClientRequestHdr') + get_struct('ClientReadVRequest')
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_readv'),
'reserved' : reserved if reserved else (15 * "\0"),
'pathid' : pathid if pathid else '0',
'dlen' : dlen if dlen else len(all_read_lists)}
return self.mh.build_message(request_struct, params) + all_read_lists
def kXR_prepare(self,
streamid=None,
requestid=None,
options=None,
prty=None,
port=None,
reserved=None,
dlen=None,
plist=None):
"""Return a packed representation of a kXR_prepare request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientPrepareRequest')
if not plist: plist = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_prepare'),
'options' : options if options else '\0',
'prty' : prty if prty else '\0',
'port' : port if port else 0,
'reserved' : reserved if reserved else (12 * "\0"),
'dlen' : dlen if dlen else len(plist),
'plist' : plist}
return self.mh.build_message(request_struct, params)
def kXR_query(self,
streamid=None,
requestid=None,
reqcode=None,
reserved1=None,
fhandle=None,
reserved2=None,
dlen=None,
args=None):
"""Return a packed representation of a kXR_query request."""
request_struct = get_struct('ClientRequestHdr') + get_struct(
'ClientQueryRequest')
if not args: args = ''
params = \
{'streamid' : streamid if streamid else self.context['streamid'],
'requestid' : requestid if requestid else get_requestid('kXR_query'),
'reqcode' : reqcode if reqcode else 0,
'reserved1' : reserved1 if reserved1 else (2 * "\0"),
'fhandle' : fhandle if fhandle else (4 * "\0"),
'reserved2' : reserved2 if reserved2 else (8 * "\0"),
'dlen' : dlen if dlen else len(args),
'args' : args}
return self.mh.build_message(request_struct, params)
def kXR_write(self, streamid=None, requestid=None, fhandle=None, offset=None,
pathid=None, reserved=None, dlen=None, data=None):
"""Return a packed representation of a kXR_write request."""
if not requestid: requestid = get_requestid('kXR_write')
return self.kXR_verifyw(streamid, requestid, fhandle, offset, pathid, None,
reserved, dlen, data)
def kXR_statx(self, streamid=None, requestid=None, reserved=None, dlen=None,
paths=None):
"""Return a packed representation of a kXR_statx request."""
if not requestid: requestid = get_requestid('kXR_statx')
return self.kXR_stat(streamid, requestid, None, reserved, None, dlen, path)
def unpack_response(self, response_raw, request_raw):
"""Return an unpacked named tuple representation of a server response."""
if not len(response_raw):
return ''
# Unpack the request that generated this response for reference
request = self.unpack_request(request_raw)[0]
requestid = get_requestid(request.type)
# Unpack the response header to find the status and data length
header_struct = get_struct('ServerResponseHeader')
format = '>'
for member in header_struct:
format += member['type']
header = self.unpack(format + (str(len(response_raw) - 8) + 's'),
response_raw)
streamid = header[0]
status = header[1]
dlen = header[2]
body = header[-1]
# Check if this is a handshake response
if requestid == XProtocol.XRequestTypes.handshake:
body_struct = get_struct('ServerInitHandShake')
# Check if this is an asynchronous response
elif status == XProtocol.XResponseType.kXR_attn:
# Extract the attn code
attncode = self.unpack('>H', body[:2])[0]
body_struct = get_struct('ServerResponseBody_Attn_' \
+ get_attncode(attncode)[4:])
if not body_struct:
body_struct = body_struct = get_struct(
'ServerResponseBody_Attn')
# Check if this is more than a simple kXR_ok response
elif status != XProtocol.XResponseType.kXR_ok:
body_struct = get_struct('ServerResponseBody_' \
+ get_responseid(status)[4:].title())
else:
body_struct = get_struct('ServerResponseBody_' \
+ request.type[4:].title())
if not body_struct: body_struct = list()
response_struct = header_struct + body_struct
# The number of params in a kXR_open response depends on the options that
# were passed in the request.
if requestid == XProtocol.XRequestTypes.kXR_open:
# Remove members from the response struct if the option was not given in
# the request.
response_struct[:] = [
m for m in response_struct
if self.option_included(m, request, response_raw)
]
# Build complete format string
format = '>'
for member in response_struct:
if member.has_key('size'):
if member['size'] == 'dlen':
if member.has_key('offset'):
format += str(dlen - member['offset']) + member['type']
else:
format += str(dlen) + member['type']
else:
format += str(member['size']) + member['type']
else:
format += member['type']
if len(body_struct) == 0 and dlen > 0:
format += (str(dlen) + 's')
# Unpack to regular tuple
response_tuple = self.unpack(format, response_raw)
# Convert to named tuple
response_struct.insert(0, {'name': 'type'})
type = get_responseid(status)
response = namedtuple('response',
' '.join([m['name'] for m in response_struct]))
return response(type, *response_tuple)
def kXR_rmdir(self, streamid=None, requestid=None, reserved=None, dlen=None,
path=None):
"""Return a packed representation of a kXR_rmdir request."""
if not requestid: requestid = get_requestid('kXR_rmdir')
return self.kXR_rm(streamid, requestid, reserved, dlen, path)
def unpack_response(self, response_raw, request_raw):
"""Return an unpacked named tuple representation of a server response."""
if not len(response_raw):
return ''
# Unpack the request that generated this response for reference
request = self.unpack_request(request_raw)[0]
requestid = get_requestid(request.type)
# Unpack the response header to find the status and data length
header_struct = get_struct('ServerResponseHeader')
format = '>'
for member in header_struct:
format += member['type']
header = self.unpack(format + (str(len(response_raw) - 8) + 's'),
response_raw)
streamid = header[0]
status = header[1]
dlen = header[2]
body = header[-1]
# Check if this is a handshake response
if requestid == XProtocol.XRequestTypes.handshake:
body_struct = get_struct('ServerInitHandShake')
# Check if this is an asynchronous response
elif status == XProtocol.XResponseType.kXR_attn:
# Extract the attn code
attncode = self.unpack('>H', body[:2])[0]
body_struct = get_struct('ServerResponseBody_Attn_' \
+ get_attncode(attncode)[4:])
if not body_struct:
body_struct = body_struct = get_struct('ServerResponseBody_Attn')
# Check if this is more than a simple kXR_ok response
elif status != XProtocol.XResponseType.kXR_ok:
body_struct = get_struct('ServerResponseBody_' \
+ get_responseid(status)[4:].title())
else:
body_struct = get_struct('ServerResponseBody_' \
+ request.type[4:].title())
if not body_struct: body_struct = list()
response_struct = header_struct + body_struct
# The number of params in a kXR_open response depends on the options that
# were passed in the request.
if requestid == XProtocol.XRequestTypes.kXR_open:
# Remove members from the response struct if the option was not given in
# the request.
response_struct[:] = [m for m in response_struct
if self.option_included(m, request, response_raw)]
# Build complete format string
format = '>'
for member in response_struct:
if member.has_key('size'):
if member['size'] == 'dlen':
if member.has_key('offset'):
format += str(dlen - member['offset']) + member['type']
else:
format += str(dlen) + member['type']
else:
format += str(member['size']) + member['type']
else:
format += member['type']
if len(body_struct) == 0 and dlen > 0:
format += (str(dlen) + 's')
# Unpack to regular tuple
response_tuple = self.unpack(format, response_raw)
# Convert to named tuple
response_struct.insert(0, {'name': 'type'})
type = get_responseid(status)
response = namedtuple('response',
' '.join([m['name'] for m in response_struct]))
return response(type, *response_tuple)
