Changed to use new make_call method

diff --git a/Demo/rpc/mountclient.py b/Demo/rpc/mountclient.py
index 269dfbc98c0500825705062c4d2a9c0ca6ac8509..fde6f4d527084da3843cd1b00b507764af255b4c 100644 (file)
--- a/Demo/rpc/mountclient.py
+++ b/Demo/rpc/mountclient.py
@@ -86,7 +86,11 @@ class PartialMountClient:
        # we want to bind to a reserved port
        def bindsocket(self):
                import os
-               if os.getuid() == 0:
+               try:
+                       uid = os.getuid()
+               except AttributeError:
+                       uid = 1
+               if uid == 0:
                        port = rpc.bindresvport(self.sock, '')
                        # 'port' is not used
                else:
@@ -100,53 +104,54 @@ class PartialMountClient:
                return self.cred
 
        # The methods Mnt, Dump etc. each implement one Remote
-       # Procedure Call.  Their general structure is
-       #  self.start_call(<procedure-number>)
-       #  <pack arguments using self.packer>
-       #  self.do_call()       # This does the actual message exchange
-       #  <unpack reply using self.unpacker>
-       #  self.end_call()
-       #  return <reply>
-       # If the call fails, an exception is raised by do_call().
-       # If the reply does not match what you unpack, an exception is
-       # raised either during unpacking (if you overrun the buffer)
-       # or by end_call() (if you leave values in the buffer).
-       # Calling packer methods with invalid arguments (e.g. if
-       # invalid arguments were passed from outside) will also result
-       # in exceptions during packing.
+       # Procedure Call.  This is done by calling self.make_call()
+       # with as arguments:
+       #
+       # - the procedure number
+       # - the arguments (or None)
+       # - the "packer" function for the arguments (or None)
+       # - the "unpacker" function for the return value (or None)
+       #
+       # The packer and unpacker function, if not None, *must* be
+       # methods of self.packer and self.unpacker, respectively.
+       # A value of None means that there are no arguments or is no
+       # return value, respectively.
+       #
+       # The return value from make_call() is the return value from
+       # the remote procedure call, as unpacked by the "unpacker"
+       # function, or None if the unpacker function is None.
+       #
+       # (Even if you expect a result of None, you should still
+       # return the return value from make_call(), since this may be
+       # needed by a broadcasting version of the class.)
+       #
+       # If the call fails, make_call() raises an exception
+       # (this includes time-outs and invalid results).
+       #
+       # Note that (at least with the UDP protocol) there is no
+       # guarantee that a call is executed at most once.  When you do
+       # get a reply, you know it has been executed at least once;
+       # when you don't get a reply, you know nothing.
 
        def Mnt(self, directory):
-               self.start_call(1)
-               self.packer.pack_string(directory)
-               self.do_call()
-               stat = self.unpacker.unpack_fhstatus()
-               self.end_call()
-               return stat
+               return self.make_call(1, directory, \
+                       self.packer.pack_string, \
+                       self.unpacker.unpack_fhstatus)
 
        def Dump(self):
-               self.start_call(2)
-               self.do_call()
-               list = self.unpacker.unpack_mountlist()
-               self.end_call()
-               return list
+               return self.make_call(2, None, \
+                       None, self.unpacker.unpack_mountlist)
 
        def Umnt(self, directory):
-               self.start_call(3)
-               self.packer.pack_string(directory)
-               self.do_call()
-               self.end_call()
+               return self.make_call(3, directory, \
+                       self.packer.pack_string, None)
 
        def Umntall(self):
-               self.start_call(4)
-               self.do_call()
-               self.end_call()
+               return self.make_call(4, None, None, None)
 
        def Export(self):
-               self.start_call(5)
-               self.do_call()
-               list = self.unpacker.unpack_exportlist()
-               self.end_call()
-               return list
+               return self.make_call(5, None, \
+                       None, self.unpacker.unpack_exportlist)
 
 
 # We turn the partial Mount client into a full one for either protocol