Improved handling of strings, converting to and from Unicode strings where needed and using byte strings when sending socket data and interacting with the operating system. Tried to make the modules compatible with both Python 2 and Python 3.

David Boddie committed 8 years ago

Commit 20f573c1 parent c2476e84 files · +66 −51Browse files

Unified · Split

4 files

dictserver.py +21 −19
localfileserver.py +36 −28
styx.py +5 −3
styxserver.py +4 −1

 #!/usr/bin/env python
+# -*- encoding: utf8 -*-
 # dictserver.py - Serves the contents of a Python dictionary.
 #
     def get_root_qid(self, fid, afid, uname, aname):
-        qid = self.make_qid("")
+        qid = self.make_qid(u"/")
-        self.set_qid_path(fid, qid, "")
+        self.set_qid_path(fid, qid, u"/")
         self.root_fid = fid
         return qid
     def set_qid_path(self, fid, qid, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
         self.qids[fid] = qid
         self.paths[fid] = path
     def make_qid(self, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
         obj = self.traverse(path)
         if obj == None:
     def _stat(self, qid, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
         obj = self.traverse(path)
         if type(obj) == dict:
             mode = 0x80000000
             size = 0
-            mode |= 0555
+            mode |= 0o555
         else:
             mode = 0
             size = len(obj)
-            mode |= 0444
+            mode |= 0o444
-        name = path.split("/")[-1]
+        name = path.split(u"/")[-1]
         return styx.Stat(0, 0, qid, mode, self.now, self.now, size, name,
-                         "inferno", "inferno", "")
+                         u"inferno", u"inferno", u"")
     def create(self, fid, name, perm):
         return False
         if obj == None:
             return None
-        data = ""
+        data = b""
         if type(obj) == dict:
             files.sort()
             for file_name in files:
-                qid = self.make_qid(path + "/" + file_name)
+                qid = self.make_qid(path + u"/" + file_name)
-                data += self._stat(qid, path + "/" + file_name).encode()
+                data += self._stat(qid, path + u"/" + file_name).encode()
             return data[offset:offset + count]
         else:
-            return obj[offset:offset + count]
+            return obj[offset:offset + count].encode("utf8")
     def write(self, fid, offset, data):
         return -2
     def remove(self, fid):
-        return False
+        return u"Cannot remove dictionary entries."
     def wstat(self, fid, st):
         pass
     def traverse(self, path):
-        if path == "":
+        if path == u"":
             return self.d
         obj = self.d
-        for element in path.split("/"):
+        for element in path.split(u"/"):
             try:
                 obj = obj[element]
     port = int(sys.argv[1])
     dictionary = {
-        "dir": {
+        u"dir": {
-            "hello.txt": "Hello world!\n"
+            u"hello.txt": u"Hello world!\n",
+            u"\u263a": u"Forståelse"
             }
         }
     store = DictStore(dictionary)
     server = styxserver.StyxServer(store)
-    server.serve("", port)
+    server.serve(b"", port)

localfileserver.py+36−28

 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import os, stat, sys
+import locale, os, stat, sys
 import styx, styxserver
 class FileStore:
         self.paths = {}
         self.opened = {}
         self.root_fid = None
+        self.encoding = sys.getfilesystemencoding()
     def get_root_qid(self, fid, afid, uname, aname):
-        qid = self.make_qid("")
+        qid = self.make_qid(u"/")
-        self.set_qid_path(fid, qid, "")
+        self.set_qid_path(fid, qid, u"/")
         self.root_fid = fid
         return qid
     def set_qid_path(self, fid, qid, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
         self.qids[fid] = qid
         self.paths[fid] = path
     def make_qid(self, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
-        real_path = os.path.join(self.dir, path)
+        real_path = os.path.join(self.dir, path).encode(self.encoding)
         try:
             s = os.stat(real_path)
     def _stat(self, qid, path):
-        path = path.lstrip("/")
+        path = path.lstrip(u"/")
         name = os.path.split(path)[1]
-        real_path = os.path.join(self.dir, path)
+        real_path = os.path.join(self.dir, path).encode(self.encoding)
         try:
             s = os.stat(real_path)
             mode = 0
             size = s.st_size
-        mode |= (s.st_mode & 0777)
+        mode |= (s.st_mode & 0o777)
         return styx.Stat(0, 0, qid, mode, s.st_atime, s.st_mtime, size,
-                         name, "styxfs", "styxfs", "")
+                         name, u"styxfs", u"styxfs", u"")
     def create(self, fid, name, perm):
-        if name in (".", ".."):
+        if name in (u".", u".."):
             return False
         elif fid in self.opened:
         else:
             # Obtain the real path of the directory.
             path = self.paths[fid]
-            real_path = os.path.join(self.dir, path)
+            real_path = os.path.join(self.dir, path).encode(self.encoding)
             if not os.path.isdir(real_path):
                 return False
             # Read the directory permissions.
             dir_perm = os.stat(real_path).st_mode
-            new_real_path = os.path.join(real_path, name)
+            new_real_path = os.path.join(self.dir, path, name).encode(self.encoding)
             if os.path.exists(new_real_path):
                 return False
                 if perm & styx.Stat.DMDIR:
                     # Only pass the lowest permission bits through to the
                     # underlying filing system.
-                    mode = dir_perm & 0777
+                    mode = dir_perm & 0o777
                     os.mkdir(new_real_path, mode)
                 else:
-                    mode = dir_perm & 0666
+                    mode = dir_perm & 0o666
                     os.mknod(new_real_path, mode, stat.S_IFREG)
             except OSError:
                 return False
             # Update the fid to refer to the new object.
-            qid = self.make_qid(path + "/" + name)
+            qid = self.make_qid(path + u"/" + name)
-            self.set_qid_path(fid, qid, path + "/" + name)
+            self.set_qid_path(fid, qid, path + u"/" + name)
         return qid
         path = self.paths[fid]
         real_path = os.path.join(self.dir, path)
-        data = ""
+        data = b""
         if os.path.isdir(real_path):
             files.sort()
             for file_name in files:
-                qid = self.make_qid(path + "/" + file_name)
+                qid = self.make_qid(path + u"/" + file_name)
-                data += self._stat(qid, path + "/" + file_name).encode()
+                data += self._stat(qid, path + u"/" + file_name).encode()
             return data[offset:offset + count]
         else:
         if os.path.isdir(real_path):
             return -1
-        f = open(real_path, "r+wb")
+        f = open(real_path, "r+b")
         f.seek(offset)
         f.write(data)
         f.close()
             else:
                 os.remove(real_path)
-        except OSError, e:
+        except OSError as e:
             return str(e)
         return True
     def wstat(self, fid, st):
         path = self.paths[fid]
-        real_path = os.path.join(self.dir, path)
+        real_path = os.path.join(self.dir, path).encode(self.encoding)
+        pieces = path.split(u"/")
+        old_name = pieces[-1]
-        old_name = path.split("/")[-1]
+        # Only update the name if the specified name is not empty and differs
-        if st.name != "" and st.name != old_name:
+        # from the existing path.
-            new_path = os.path.join(os.path.split(real_path)[0], st.name)
+        if st.name != u"" and st.name != old_name:
+            # Rename the file and use the new path for any further operations.
+            new_path = os.path.join(os.path.split(real_path)[0], st.name).encode(self.encoding)
             os.rename(real_path, new_path)
             real_path = new_path
+            # Update the path dictionary to contain the new path.
+            self.paths[fid] = pieces + [u"/" + st.name]
         s = os.stat(real_path)
         if st.mode != 0xffffffff:
-            os.chmod(real_path, st.mode & 0777)
+            os.chmod(real_path, st.mode & 0o777)
         if st.mtime != 0xffffffff or st.atime != 0xffffffff:
             if st.mtime == 0xffffffff:
     store = FileStore(directory)
     server = styxserver.StyxServer(store)
-    server.serve("", port)
+    server.serve(b"", port)

styx.py+5−3

         self.sock = sock
     def recv(self, n):
-        data = ""
+        data = b""
         while len(data) < n:
             data += self.sock.recv(n - len(data))
 def encode_format(stream, obj):
-    data = ""
+    data = b""
     for name, length in obj.format:
     def encode(self):
-        args = (self.type, self.dev) + self.qid + (self.mode, self.atime, self.mtime, self.length)
+        args = (self.type, self.dev) + self.qid + \
+               (self.mode, int(self.atime), int(self.mtime), self.length)
         data = struct.pack("<HIBIQIIIQ", *args)
         data += encode_string(self.name)
         data += encode_string(self.uid)

styxserver.py+4−1

                     reply = handler(self, conn, client, message)
                 except KeyError:
                     reply = styx.Rerror(message.tag, "Unsupported message.")
-                except StyxServerError, e:
+                except StyxServerError as e:
                     reply = styx.Rerror(message.tag, e.message)
                 except socket.error:
                     # The connection was probably closed by the client.
         store = self.clients[client]
         qid = store.get_root_qid(msg.fid, msg.afid, msg.uname, msg.aname)
+        if qid == None:
+            return styx.Rerror(msg.tag, "Root not found.")
         return styx.Rattach(msg.tag, qid)
     def Tstat(self, conn, client, msg):