Demo/rpc/mountclient.py

   1 # Mount RPC client -- RFC 1094 (NFS), Appendix A
   2
   3 # This module demonstrates how to write your own RPC client in Python.
   4 # When this example was written, there was no RPC compiler for
   5 # Python. Without such a compiler, you must first create classes
   6 # derived from Packer and Unpacker to handle the data types for the
   7 # server you want to interface to.  You then write the client class.
   8 # If you want to support both the TCP and the UDP version of a
   9 # protocol, use multiple inheritance as shown below.
  10
  11
  12 import rpc
  13 from rpc import Packer, Unpacker, TCPClient, UDPClient
  14
  15
  16 # Program number and version for the mount protocol
  17 MOUNTPROG = 100005
  18 MOUNTVERS = 1
  19
  20 # Size of the 'fhandle' opaque structure
  21 FHSIZE = 32
  22
  23
  24 # Packer derived class for Mount protocol clients.
  25 # The only thing we need to pack beyond basic types is an 'fhandle'
  26
  27 class MountPacker(Packer):
  28
  29     def pack_fhandle(self, fhandle):
  30         self.pack_fopaque(FHSIZE, fhandle)
  31
  32
  33 # Unpacker derived class for Mount protocol clients.
  34 # The important types we need to unpack are fhandle, fhstatus,
  35 # mountlist and exportlist; mountstruct, exportstruct and groups are
  36 # used to unpack components of mountlist and exportlist and the
  37 # corresponding functions are passed as function argument to the
  38 # generic unpack_list function.
  39
  40 class MountUnpacker(Unpacker):
  41
  42     def unpack_fhandle(self):
  43         return self.unpack_fopaque(FHSIZE)
  44
  45     def unpack_fhstatus(self):
  46         status = self.unpack_uint()
  47         if status == 0:
  48             fh = self.unpack_fhandle()
  49         else:
  50             fh = None
  51         return status, fh
  52
  53     def unpack_mountlist(self):
  54         return self.unpack_list(self.unpack_mountstruct)
  55
  56     def unpack_mountstruct(self):
  57         hostname = self.unpack_string()
  58         directory = self.unpack_string()
  59         return (hostname, directory)
  60
  61     def unpack_exportlist(self):
  62         return self.unpack_list(self.unpack_exportstruct)
  63
  64     def unpack_exportstruct(self):
  65         filesys = self.unpack_string()
  66         groups = self.unpack_groups()
  67         return (filesys, groups)
  68
  69     def unpack_groups(self):
  70         return self.unpack_list(self.unpack_string)
  71
  72
  73 # These are the procedures specific to the Mount client class.
  74 # Think of this as a derived class of either TCPClient or UDPClient.
  75
  76 class PartialMountClient:
  77
  78     # This method is called by Client.__init__ to initialize
  79     # self.packer and self.unpacker
  80     def addpackers(self):
  81         self.packer = MountPacker()
  82         self.unpacker = MountUnpacker('')
  83
  84     # This method is called by Client.__init__ to bind the socket
  85     # to a particular network interface and port.  We use the
  86     # default network interface, but if we're running as root,
  87     # we want to bind to a reserved port
  88     def bindsocket(self):
  89         import os
  90         try:
  91             uid = os.getuid()
  92         except AttributeError:
  93             uid = 1
  94         if uid == 0:
  95             port = rpc.bindresvport(self.sock, '')
  96             # 'port' is not used
  97         else:
  98             self.sock.bind(('', 0))
  99
 100     # This function is called to cough up a suitable
 101     # authentication object for a call to procedure 'proc'.
 102     def mkcred(self):
 103         if self.cred is None:
 104             self.cred = rpc.AUTH_UNIX, rpc.make_auth_unix_default()
 105         return self.cred
 106
 107     # The methods Mnt, Dump etc. each implement one Remote
 108     # Procedure Call.  This is done by calling self.make_call()
 109     # with as arguments:
 110     #
 111     # - the procedure number
 112     # - the arguments (or None)
 113     # - the "packer" function for the arguments (or None)
 114     # - the "unpacker" function for the return value (or None)
 115     #
 116     # The packer and unpacker function, if not None, *must* be
 117     # methods of self.packer and self.unpacker, respectively.
 118     # A value of None means that there are no arguments or is no
 119     # return value, respectively.
 120     #
 121     # The return value from make_call() is the return value from
 122     # the remote procedure call, as unpacked by the "unpacker"
 123     # function, or None if the unpacker function is None.
 124     #
 125     # (Even if you expect a result of None, you should still
 126     # return the return value from make_call(), since this may be
 127     # needed by a broadcasting version of the class.)
 128     #
 129     # If the call fails, make_call() raises an exception
 130     # (this includes time-outs and invalid results).
 131     #
 132     # Note that (at least with the UDP protocol) there is no
 133     # guarantee that a call is executed at most once.  When you do
 134     # get a reply, you know it has been executed at least once;
 135     # when you don't get a reply, you know nothing.
 136
 137     def Mnt(self, directory):
 138         return self.make_call(1, directory, \
 139                 self.packer.pack_string, \
 140                 self.unpacker.unpack_fhstatus)
 141
 142     def Dump(self):
 143         return self.make_call(2, None, \
 144                 None, self.unpacker.unpack_mountlist)
 145
 146     def Umnt(self, directory):
 147         return self.make_call(3, directory, \
 148                 self.packer.pack_string, None)
 149
 150     def Umntall(self):
 151         return self.make_call(4, None, None, None)
 152
 153     def Export(self):
 154         return self.make_call(5, None, \
 155                 None, self.unpacker.unpack_exportlist)
 156
 157
 158 # We turn the partial Mount client into a full one for either protocol
 159 # by use of multiple inheritance.  (In general, when class C has base
 160 # classes B1...Bn, if x is an instance of class C, methods of x are
 161 # searched first in C, then in B1, then in B2, ..., finally in Bn.)
 162
 163 class TCPMountClient(PartialMountClient, TCPClient):
 164
 165     def __init__(self, host):
 166         TCPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)
 167
 168
 169 class UDPMountClient(PartialMountClient, UDPClient):
 170
 171     def __init__(self, host):
 172         UDPClient.__init__(self, host, MOUNTPROG, MOUNTVERS)
 173
 174
 175 # A little test program for the Mount client.  This takes a host as
 176 # command line argument (default the local machine), prints its export
 177 # list, and attempts to mount and unmount each exported files system.
 178 # An optional first argument of -t or -u specifies the protocol to use
 179 # (TCP or UDP), default is UDP.
 180
 181 def test():
 182     import sys
 183     if sys.argv[1:] and sys.argv[1] == '-t':
 184         C = TCPMountClient
 185         del sys.argv[1]
 186     elif sys.argv[1:] and sys.argv[1] == '-u':
 187         C = UDPMountClient
 188         del sys.argv[1]
 189     else:
 190         C = UDPMountClient
 191     if sys.argv[1:]: host = sys.argv[1]
 192     else: host = ''
 193     mcl = C(host)
 194     list = mcl.Export()
 195     for item in list:
 196         print item
 197         try:
 198             mcl.Mnt(item[0])
 199         except:
 200             print 'Sorry'
 201             continue
 202         mcl.Umnt(item[0])