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 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 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)