Lines Matching refs:self
59 def __init__(self, client, op, msg, etype, errno): argument
60 self.client = str(client)
61 self.op = op
62 self.msg = msg
63 self.etype = etype # 'Rerror' or 'Rlerror'
64 self.errno = errno # may be None
65 self.message = self._get_message()
66 super(RemoteError, self).__init__(self, self.message)
68 def __repr__(self): argument
70 '{5})'.format(self.__class__.__name__, self.client, self.op,
71 self.msg, self.errno, self.etype))
72 def __str__(self): argument
73 prefix = '{0}: {1}: '.format(self.client, self.op)
74 if self.errno: # check for "is not None", or just non-false-y?
75 name = {'Rerror': '.u', 'Rlerror': 'Linux'}[self.etype]
76 middle = '[{0} error {1}] '.format(name, self.errno)
79 return '{0}{1}{2}'.format(prefix, middle, self.message)
81 def is_ENOTSUP(self): argument
82 if self.etype == 'Rlerror':
83 return self.errno == lerrno.EOPNOTSUPP
84 return self.errno == errno.EOPNOTSUPP
86 def _get_message(self): argument
88 if self.errno is not None:
92 }[self.etype](self.errno)
93 return self.msg
109 def __init__(self, logger, name=None, server=None, port=STD_P9_PORT): argument
110 self.logger = logger
111 self.channel = None
112 self.name = name
113 self.maxio = None
114 self.size_coder = struct.Struct('<I')
116 self.connect(server, port)
117 self.max_payload = 2**32 - self.size_coder.size
119 def __str__(self): argument
120 if self.name:
121 return self.name
122 return repr(self)
124 def get_recommended_maxio(self): argument
128 def min_maxio(self): argument
130 return self.size_coder.size + 100
132 def connect(self, server, port=STD_P9_PORT): argument
138 if self.is_connected():
142 if self.name is None:
149 self.declare_connected(sock, name, None)
151 def is_connected(self): argument
153 return self.channel != None
155 def declare_connected(self, chan, name, maxio): argument
163 minio = self.min_maxio()
167 self.channel = chan
169 self.name = name
171 self.maxio = maxio
172 self.max_payload = maxio - self.size_coder.size
174 def reduce_maxio(self, maxio): argument
176 minio = self.min_maxio()
179 if maxio > self.maxio:
181 self.maxio))
182 self.maxio = maxio
183 self.max_payload = maxio - self.size_coder.size
185 def declare_disconnected(self): argument
187 self.channel = None
188 self.maxio = None
190 def shutwrite(self): argument
192 chan = self.channel
199 def shutdown(self): argument
201 if self.channel:
203 self.channel.shutdown(socket.SHUT_RDWR)
206 self.channel.close()
207 self.declare_disconnected()
209 def read(self): argument
224 if self.channel is None:
226 size_field = self.xread(self.size_coder.size)
227 if len(size_field) < self.size_coder.size:
229 self.logger.log(logging.INFO, '%s: normal EOF', self)
231 self.logger.log(logging.ERROR,
233 self, len(size_field))
237 size = self.size_coder.unpack(size_field)[0] - self.size_coder.size
238 if size <= 0 or size > self.max_payload:
239 self.logger.log(logging.ERROR,
242 self, size, self.max_payload)
245 data = self.xread(size)
248 def xread(self, nbytes): argument
257 data = self.channel.recv(nbytes)
266 more = self.channel.recv(nbytes - count)
273 def write(self, data): argument
286 if size > self.max_payload:
288 'maximum {1}'.format(size, self.max_payload))
289 self.channel.sendall(data)
325 def __init__(self, logger, timeout, version, may_downgrade=True, argument
327 super(P9Client, self).__init__(logger)
328 self.timeout = timeout
329 self.iproto = protocol.p9_version(version)
330 self.may_downgrade = may_downgrade
331 self.tagalloc = numalloc.NumAlloc(0, 65534)
332 self.tagstate = {}
336 self.fidalloc = numalloc.NumAlloc(0, protocol.td.NOFID - 1)
337 self.live_fids = {}
338 self.rootfid = None
339 self.rootqid = None
340 self.rthread = None
341 self.lock = threading.Lock()
342 self.new_replies = threading.Condition(self.lock)
343 self._monkeywrench = {}
344 self._server = server
345 self._port = port
346 self._unsup = {}
348 def get_monkey(self, what): argument
350 with self.lock:
351 wrench = self._monkeywrench.get(what)
360 del self._monkeywrench[what]
363 del self._monkeywrench[what]
366 def set_monkey(self, what, how, repeat=None): argument
374 with self.lock:
376 del self._monkeywrench[what]
382 with self.lock:
383 self._monkeywrench[what] = how
385 def get_tag(self, for_Tversion=False): argument
387 with self.lock:
391 tag = self.tagalloc.alloc()
394 self.tagstate[tag] = True # ie, in use, still waiting
397 def set_tag(self, tag, reply): argument
400 with self.lock:
402 state = self.tagstate.get(tag)
404 self.tagstate[tag] = reply # i.e., here's the answer
405 self.new_replies.notify_all()
410 self.logger.log(logging.INFO,
412 self, tag, reply)
413 self.retire_tag_locked(tag)
418 self.logger.log(logging.WARNING,
420 self, tag, reply, tag)
423 self.logger.log(logging.WARNING,
425 self, tag, reply, tag, state)
428 def retire_tag(self, tag): argument
433 with self.lock:
434 self.retire_tag_locked(tag)
436 def retire_tag_locked(self, tag): argument
440 if tag in self.tagstate:
441 del self.tagstate[tag]
442 self.tagalloc.free(tag)
444 def retire_all_tags(self): argument
446 with self.lock:
448 self.tagalloc.free_multi(self.tagstate.keys())
449 self.tagstate = {}
450 self.new_replies.notify_all()
452 def alloc_fid(self): argument
454 with self.lock:
455 fid = self.fidalloc.alloc()
456 self.live_fids[fid] = True
459 def getpath(self, fid): argument
461 with self.lock:
462 path = self.live_fids.get(fid)
467 def getpathX(self, fid): argument
472 path = self.getpath(fid)
477 def setpath(self, fid, path): argument
479 with self.lock:
481 path = self.live_fids.get(path)
488 if self.live_fids.get(fid):
491 self.live_fids[fid] = path
493 def did_rename(self, fid, ncomp, newdir=None): argument
514 opath = self.getpath(fid)
529 with self.lock:
530 if fid in self.live_fids:
531 self.live_fids[fid] = npath
542 with self.lock:
543 for fid2, path2 in self.live_fids.iteritems():
565 self.live_fids[fid2] = b'/'.join(parts2)
567 def retire_fid(self, fid): argument
569 with self.lock:
570 self.fidalloc.free(fid)
571 del self.live_fids[fid]
573 def retire_all_fids(self): argument
578 with self.lock:
579 self.fidalloc.free_multi(self.live_fids.keys())
580 self.live_fids = {}
582 def read_responses(self): argument
584 while self.is_connected():
585 pkt, is_full = super(P9Client, self).read()
587 self.shutwrite()
588 self.retire_all_tags()
591 self.logger.log(logging.WARNING, '%s: got short packet', self)
596 if self.have_version:
597 resp = self.proto.unpack(pkt)
601 self.logger.log(logging.ERROR, '%s: bad response: %s',
602 self, err)
604 resp = self.proto.unpack(pkt, noerror=True)
606 header = self.proto.unpack_header(pkt, noerror=True)
607 self.logger.log(logging.ERROR,
608 '%s: (not even raw-decodable)', self)
609 self.logger.log(logging.ERROR,
611 self, header)
613 self.logger.log(logging.ERROR,
615 self, resp)
621 self.logger.log(logging.DEBUG, "read_resp: tag %d resp %r", resp.tag, resp)
622 self.set_tag(resp.tag, resp)
624 def wait_for(self, tag): argument
634 self.logger.log(logging.DEBUG, "wait_for: tag %d", tag)
635 if self.timeout is None:
638 deadline = time.time() + self.timeout
639 with self.lock:
644 resp = self.tagstate.get(tag, None)
650 self.new_replies.wait(self.timeout)
654 if tag in self.tagstate:
655 self.tagstate[tag] = False
666 self.tagalloc.free(tag)
667 del self.tagstate[tag]
671 def badresp(self, req, resp): argument
676 self.shutdown()
677 raise TEError('{0}: {1}: timeout or EOF'.format(self, req))
679 raise RemoteError(self, req, None, 'Rlerror', resp.ecode)
682 raise RemoteError(self, req, resp.errstr, 'Rerror', None)
683 raise RemoteError(self, req, None, 'Rerror', resp.errnum)
684 raise LocalError('{0}: {1} got response {2!r}'.format(self, req, resp))
686 def supports(self, req_code): argument
691 return req_code not in self._unsup and self.proto.supports(req_code)
693 def supports_all(self, *req_codes): argument
695 return all(self.supports(code) for code in req_codes)
697 def unsupported(self, req_code): argument
703 self._unsup[req_code] = True
705 def connect(self, server=None, port=None): argument
718 server = self._server
722 port = self._port
725 self.name = None # wipe out previous name, if any
726 super(P9Client, self).connect(server, port)
727 maxio = self.get_recommended_maxio()
728 self.declare_connected(None, None, maxio)
729 self.proto = self.iproto # revert to initial protocol
730 self.have_version = False
731 self.rthread = threading.Thread(target=self.read_responses)
732 self.rthread.start()
733 tag = self.get_tag(for_Tversion=True)
735 version=self.get_monkey('version'))
736 super(P9Client, self).write(self.proto.pack_from(req))
737 resp = self.wait_for(tag)
739 self.shutdown()
741 version = req.version or self.proto.get_version()
745 raise RemoteError(self, 'version ' + version,
747 self.badresp('version', resp)
750 self.reduce_maxio(their_maxio)
753 '{3}'.format(self, maxio, their_maxio,
755 if resp.version != self.proto.get_version():
756 if not self.may_downgrade:
757 self.shutdown()
759 'version {1!r}'.format(self, resp.version))
762 self.proto = self.proto.downgrade_to(resp.version)
763 self._server = server
764 self._port = port
765 self.have_version = True
767 def attach(self, afid, uname, aname, n_uname): argument
782 tag = self.get_tag()
783 fid = self.alloc_fid()
784 pkt = self.proto.Tattach(tag=tag, fid=fid, afid=afid,
787 super(P9Client, self).write(pkt)
788 resp = self.wait_for(tag)
790 self.retire_fid(fid)
791 self.badresp('attach', resp)
793 self.rootfid = fid
794 self.rootqid = resp.qid
795 self.setpath(fid, b'/')
797 def shutdown(self): argument
799 if self.rootfid is not None:
800 self.clunk(self.rootfid, ignore_error=True)
801 self.retire_all_tags()
802 self.retire_all_fids()
803 self.rootfid = None
804 self.rootqid = None
805 super(P9Client, self).shutdown()
806 if self.rthread:
807 self.rthread.join()
808 self.rthread = None
810 def dupfid(self, fid): argument
814 tag = self.get_tag()
815 newfid = self.alloc_fid()
816 pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid, nwname=0,
818 super(P9Client, self).write(pkt)
819 resp = self.wait_for(tag)
821 self.retire_fid(newfid)
822 self.badresp('walk {0}'.format(self.getpathX(fid)), resp)
824 self.setpath(newfid, fid)
827 def lookup(self, fid, components): argument
841 if self.rootfid is None:
842 raise LocalError('{0}: not attached'.format(self))
846 'components {1!r}'.format(self, components))
847 tag = self.get_tag()
848 newfid = self.alloc_fid()
849 startpath = self.getpath(fid)
850 pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid,
852 super(P9Client, self).write(pkt)
853 resp = self.wait_for(tag)
855 self.retire_fid(newfid)
856 self.badresp('walk {0} in '
857 '{1}'.format(components, self.getpathX(fid)),
864 self.clunk(newfid, ignore_error=True)
866 'items'.format(self, components,
867 self.getpathX(fid), resp.nwqid))
869 self.clunk(newfid, ignore_error=True)
877 self.setpath(newfid, _pathcat(startpath, b'/'.join(components)))
880 def lookup_last(self, fid, components): argument
886 rfid, wqid = self.lookup(fid, components)
889 if fid == self.rootfid: # usually true, if we get here at all
890 return rfid, self.rootqid
891 tag = self.get_tag()
892 pkt = self.proto.Tstat(tag=tag, fid=rfid)
893 super(P9Client, self).write(pkt)
894 resp = self.wait_for(tag)
896 self.badresp('stat {0}'.format(self.getpathX(fid)), resp)
897 statval = self.proto.unpack_wirestat(resp.data)
900 def clunk(self, fid, ignore_error=False): argument
902 tag = self.get_tag()
903 pkt = self.proto.Tclunk(tag=tag, fid=fid)
904 super(P9Client, self).write(pkt)
905 resp = self.wait_for(tag)
909 self.badresp('clunk {0}'.format(self.getpathX(fid)), resp)
910 self.retire_fid(fid)
912 def remove(self, fid, ignore_error=False): argument
914 tag = self.get_tag()
915 pkt = self.proto.Tremove(tag=tag, fid=fid)
916 super(P9Client, self).write(pkt)
917 resp = self.wait_for(tag)
921 self.clunk(fid, True)
923 self.badresp('remove {0}'.format(self.getpathX(fid)), resp)
924 self.retire_fid(fid)
926 def create(self, fid, name, perm, mode, filetype=None, extension=b''): argument
949 tag = self.get_tag()
958 pkt = self.proto.Tcreate(tag=tag, fid=fid, name=name,
960 super(P9Client, self).write(pkt)
961 resp = self.wait_for(tag)
963 self.badresp('create {0} in {1}'.format(name, self.getpathX(fid)),
968 self.setpath(fid, _pathcat(self.getpath(fid), name))
971 def open(self, fid, mode): argument
973 tag = self.get_tag()
974 pkt = self.proto.Topen(tag=tag, fid=fid, mode=mode)
975 super(P9Client, self).write(pkt)
976 resp = self.wait_for(tag)
978 self.badresp('open {0}'.format(self.getpathX(fid)), resp)
981 def lopen(self, fid, flags): argument
983 tag = self.get_tag()
984 pkt = self.proto.Tlopen(tag=tag, fid=fid, flags=flags)
985 super(P9Client, self).write(pkt)
986 resp = self.wait_for(tag)
988 self.badresp('lopen {0}'.format(self.getpathX(fid)), resp)
991 def read(self, fid, offset, count): argument
993 tag = self.get_tag()
994 pkt = self.proto.Tread(tag=tag, fid=fid, offset=offset, count=count)
995 super(P9Client, self).write(pkt)
996 resp = self.wait_for(tag)
998 self.badresp('read {0} bytes at offset {1} in '
999 '{2}'.format(count, offset, self.getpathX(fid)),
1003 def write(self, fid, offset, data): argument
1005 tag = self.get_tag()
1006 pkt = self.proto.Twrite(tag=tag, fid=fid, offset=offset,
1008 super(P9Client, self).write(pkt)
1009 resp = self.wait_for(tag)
1011 self.badresp('write {0} bytes at offset {1} in '
1012 '{2}'.format(len(data), offset, self.getpathX(fid)),
1024 def wstat(self, fid, statobj=None, **kwargs): argument
1037 if self.proto == protocol.plain:
1071 data = self.proto.pack_wirestat(statobj)
1072 tag = self.get_tag()
1073 pkt = self.proto.Twstat(tag=tag, fid=fid, data=data)
1074 super(P9Client, self).write(pkt)
1075 resp = self.wait_for(tag)
1085 self.badresp('wstat {0}={1}'.format(self.getpathX(fid), statobj),
1089 self.did_rename(fid, statobj.name)
1091 def readdir(self, fid, offset, count): argument
1093 tag = self.get_tag()
1094 pkt = self.proto.Treaddir(tag=tag, fid=fid, offset=offset, count=count)
1095 super(P9Client, self).write(pkt)
1096 resp = self.wait_for(tag)
1098 self.badresp('readdir {0} bytes at offset {1} in '
1099 '{2}'.format(count, offset, self.getpathX(fid)),
1103 def rename(self, fid, dfid, name): argument
1105 tag = self.get_tag()
1106 pkt = self.proto.Trename(tag=tag, fid=fid, dfid=dfid, name=name)
1107 super(P9Client, self).write(pkt)
1108 resp = self.wait_for(tag)
1110 self.badresp('rename {0} to {2} in '
1111 '{1}'.format(self.getpathX(fid),
1112 self.getpathX(dfid), name),
1114 self.did_rename(fid, name, self.getpath(dfid))
1116 def renameat(self, olddirfid, oldname, newdirfid, newname): argument
1118 tag = self.get_tag()
1119 pkt = self.proto.Trenameat(tag=tag,
1122 super(P9Client, self).write(pkt)
1123 resp = self.wait_for(tag)
1125 self.badresp('rename {1} in {0} to {3} in '
1126 '{2}'.format(oldname, self.getpathX(olddirfid),
1127 newname, self.getpathX(newdirdfid)),
1132 def unlinkat(self, dirfd, name, flags): argument
1134 tag = self.get_tag()
1135 pkt = self.proto.Tunlinkat(tag=tag, dirfd=dirfd,
1137 super(P9Client, self).write(pkt)
1138 resp = self.wait_for(tag)
1140 self.badresp('unlinkat {0} in '
1141 '{1}'.format(name, self.getpathX(dirfd)), resp)
1143 def decode_stat_objects(self, bstring, noerror=False): argument
1154 obj, offset = self.proto.unpack_wirestat(bstring, offset, noerror)
1158 def decode_readdir_dirents(self, bstring, noerror=False): argument
1168 obj, offset = self.proto.unpack_dirent(bstring, offset, noerror)
1172 def lcreate(self, fid, name, lflags, mode, gid): argument
1174 tag = self.get_tag()
1175 pkt = self.proto.Tlcreate(tag=tag, fid=fid, name=name,
1177 super(P9Client, self).write(pkt)
1178 resp = self.wait_for(tag)
1180 self.badresp('create {0} in '
1181 '{1}'.format(name, self.getpathX(fid)), resp)
1184 self.setpath(fid, _pathcat(self.getpath(fid), name))
1187 def mkdir(self, dfid, name, mode, gid): argument
1189 tag = self.get_tag()
1190 pkt = self.proto.Tmkdir(tag=tag, dfid=dfid, name=name,
1192 super(P9Client, self).write(pkt)
1193 resp = self.wait_for(tag)
1195 self.badresp('mkdir {0} in '
1196 '{1}'.format(name, self.getpathX(dfid)), resp)
1200 def Tgetattr(self, fid, request_mask=protocol.td.GETATTR_ALL): argument
1202 tag = self.get_tag()
1203 pkt = self.proto.Tgetattr(tag=tag, fid=fid, request_mask=request_mask)
1204 super(P9Client, self).write(pkt)
1205 resp = self.wait_for(tag)
1207 self.badresp('Tgetattr {0} of '
1208 '{1}'.format(request_mask, self.getpathX(fid)), resp)
1239 def Tsetattr(self, fid, valid=0, attrs=None, **kwargs): argument
1312 tag = self.get_tag()
1316 pkt = self.proto.pack(attrobj)
1317 super(P9Client, self).write(pkt)
1318 resp = self.wait_for(tag)
1320 self.badresp('Tsetattr {0} {1} of '
1321 '{2}'.format(valid, attrs, self.getpathX(fid)), resp)
1323 def xattrwalk(self, fid, name=None): argument
1325 tag = self.get_tag()
1326 newfid = self.alloc_fid()
1327 pkt = self.proto.Txattrwalk(tag=tag, fid=fid, newfid=newfid,
1329 super(P9Client, self).write(pkt)
1330 resp = self.wait_for(tag)
1332 self.retire_fid(newfid)
1333 self.badresp('Txattrwalk {0} of '
1334 '{1}'.format(name, self.getpathX(fid)), resp)
1336 self.setpath(newfid, 'xattr:' + name)
1338 self.setpath(newfid, 'xattr')
1341 def _pathsplit(self, path, startdir, allow_empty=False): argument
1343 if self.rootfid is None:
1344 raise LocalError('{0}: not attached'.format(self))
1346 startdir = self.rootfid
1349 raise LocalError('{0}: {1!r}: empty path'.format(self, path))
1352 def uxlookup(self, path, startdir=None): argument
1358 components, startdir = self._pathsplit(path, startdir, allow_empty=True)
1359 return self.lookup_last(startdir, components)
1361 def uxopen(self, path, oflags=0, perm=None, gid=None, argument
1384 components, startdir = self._pathsplit(path, startdir,
1388 fid, qid = self.lookup_last(startdir, components)
1391 return self._uxopen2(path, needtype, fid, qid, omode_byte, False)
1400 fid, _ = self.lookup(startdir, components[:-1])
1411 fid = self.alloc_fid()
1415 tag = self.get_tag()
1416 pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
1418 super(P9Client, self).write(pkt)
1419 resp = self.wait_for(tag)
1422 self.clunk(startdir, ignore_error=True)
1425 self.setpath(fid, _pathcat(self.getpath(startdir), components[0]))
1427 return self._uxopen2(needtype, fid, qid, omode_byte, False)
1436 self.retire_fid(fid)
1437 fid = self.dupfid(startdir)
1440 qid, iounit = self._uxcreate(filetype, fid, components[0],
1452 self.clunk(fid, ignore_error=True)
1460 fid = self.alloc_fid()
1461 tag = self.get_tag()
1462 pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
1464 super(P9Client, self).write(pkt)
1465 resp = self.wait_for(tag)
1467 self.clunk(fid, ignore_error=True)
1471 self.setpath(fid, _pathcat(self.getpath(fid), components[0]))
1472 return self._uxopen2(needtype, fid, qid, omode_byte, True)
1477 self.clunk(startdir, ignore_error=True)
1479 def _uxcreate(self, filetype, fid, name, oflags, omode_byte, perm, gid): argument
1488 if self.supports_all(protocol.td.Tlcreate, protocol.td.Tmkdir):
1493 return self.mkdir(startdir, name, perm, gid), None
1497 return self.lcreate(fid, name, lflags, perm, gid)
1507 return self.create(fid, name, perm, omode_byte)
1509 def _uxopen2(self, needtype, fid, qid, omode_byte, didcreate): argument
1512 self.clunk(fid, ignore_error=True)
1516 qid, iounit = self.open(fid, omode_byte)
1520 def uxmkdir(self, path, perm, gid, startdir=None): argument
1526 components, startdir = self._pathsplit(path, startdir)
1529 fid, _ = self.lookup(startdir, components[:-1])
1534 if self.supports(protocol.td.Tmkdir):
1535 qid = self.mkdir(startdir, components[0], perm, gid)
1537 qid, _ = self.create(startdir, components[0],
1543 self.clunk(clunkme, ignore_error=True)
1546 def uxreaddir(self, path, startdir=None, no_dotl=False): argument
1555 components, startdir = self._pathsplit(path, startdir, allow_empty=True)
1556 fid, qid = self.lookup_last(startdir, components)
1560 '{0}: {1}'.format(self.getpathX(fid),
1563 if not self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
1566 statvals = self.uxreaddir_stat_fid(fid)
1569 dirents = self.uxreaddir_dotl_fid(fid)
1572 self.clunk(fid, ignore_error=True)
1574 def uxreaddir_stat(self, path, startdir=None): argument
1589 components, startdir = self._pathsplit(path, startdir)
1590 fid, qid = self.lookup_last(startdir, components)
1594 '{0}: {1}'.format(self.getpathX(fid),
1596 statvals = self.ux_readdir_stat_fid(fid)
1599 self.clunk(fid, ignore_error=True)
1601 def uxreaddir_stat_fid(self, fid): argument
1610 qid, iounit = self.open(fid, protocol.td.OREAD)
1617 bstring = self.read(fid, offset, iounit)
1620 statvals.extend(self.decode_stat_objects(bstring))
1624 def uxreaddir_dotl_fid(self, fid): argument
1633 qid, iounit = self.lopen(fid, protocol.td.OREAD |
1641 bstring = self.readdir(fid, offset, iounit)
1644 ents = self.decode_readdir_dirents(bstring)
1651 def uxremove(self, path, startdir=None, filetype=None, argument
1662 components, startdir = self._pathsplit(path, startdir, allow_empty=True)
1667 fid, qid = self.lookup_last(startdir, components)
1674 self.clunk(fid, ignore_error=True)
1678 closer = self.clunk if isroot else self.remove
1681 self._rm_recursive(fid, filetype, force)
1688 self.clunk(fid, ignore_error=True)
1691 self.remove(fid, ignore_error=force)
1693 def _rm_file_by_dfid(self, dfid, name, force=False): argument
1705 if self.supports(protocol.td.Tunlinkat):
1707 self.unlinkat(dfid, name, 0)
1712 self.unsupported(protocol.td.Tunlinkat)
1716 fid, qid = self.lookup_last(dfid, [name])
1721 self.remove(fid, ignore_error=force)
1723 def _rm_recursive(self, dfid, filetype, force): argument
1735 if self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
1736 for entry in self.uxreaddir_dotl_fid(dfid):
1739 fid, qid = self.lookup(dfid, [entry.name])
1741 attrs = self.Tgetattr(fid, protocol.td.GETATTR_MODE)
1743 self.uxremove(entry.name, dfid, filetype, force, True)
1745 self.remove(fid)
1749 self.clunk(fid, ignore_error=True)
1751 for statobj in self.uxreaddir_stat_fid(dfid):
1757 self.uxremove(name, dfid, filetype, force, True)
1759 self._rm_file_by_dfid(dfid, name, force)