This page presents a very simple client to access a server that implements the file system we developed in Slice for a Simple File System. The Python code shown here hardly differs from the code you would write for an ordinary Python program. This is one of the biggest advantages of using Ice: accessing a remote object is as easy as accessing an ordinary, local Python object. This allows you to put your effort where you should, namely, into developing your application logic instead of having to struggle with arcane networking APIs. This is true for the server side as well, meaning that you can develop distributed applications easily and efficiently.
We now have seen enough of the client-side Python mapping to develop a complete client to access our remote file system. For reference, here is the Slice definition once more:
{zcode:slice} module Filesystem { interface Node { idempotent string name(); }; exception GenericError { string reason; }; sequence<string> Lines; interface File extends Node { idempotent Lines read(); idempotent void write(Lines text) throws GenericError; }; sequence<Node*> NodeSeq; interface Directory extends Node { idempotent NodeSeq list(); }; }; {zcode} |
To exercise the file system, the client does a recursive listing of the file system, starting at the root directory. For each node in the file system, the client shows the name of the node and whether that node is a file or directory. If the node is a file, the client retrieves the contents of the file and prints them.
The body of the client code looks as follows:
{zcode:py} import sys, traceback, Ice, Filesystem # Recursively print the contents of directory "dir" # in tree fashion. For files, show the contents of # each file. The "depth" parameter is the current # nesting level (for indentation). def listRecursive(dir, depth): indent = '' depth = depth + 1 for i in range(depth): indent = indent + '\t' contents = dir.list() for node in contents: subdir = Filesystem.DirectoryPrx.checkedCast(node) file = Filesystem.FilePrx.uncheckedCast(node) print indent + node.name(), if subdir: print "(directory):" listRecursive(subdir, depth) else: print "(file):" text = file.read() for line in text: print indent + "\t" + line status = 0 ic = None try: # Create a communicator # ic = Ice.initialize(sys.argv) # Create a proxy for the root directory # obj = ic.stringToProxy("RootDir:default -p 10000") # Down-cast the proxy to a Directory proxy # rootDir = Filesystem.DirectoryPrx.checkedCast(obj) # Recursively list the contents of the root directory # print "Contents of root directory:" listRecursive(rootDir, 0) except: traceback.print_exc() status = 1 if ic: # Clean up # try: ic.destroy() except: traceback.print_exc() status = 1 sys.exit(status) {zcode} |
The program first defines the listRecursive
function, which is a helper function to print the contents of the file system, and the main program follows. Let us look at the main program first:
RootDir
.DirectoryPrx
and passes that proxy to listRecursive
, which prints the contents of the file system.Most of the work happens in listRecursive
. The function is passed a proxy to a directory to list, and an indent level. (The indent level increments with each recursive call and allows the code to print the name of each node at an indent level that corresponds to the depth of the tree at that node.) listRecursive
calls the list
operation on the directory and iterates over the returned sequence of nodes:
checkedCast
to narrow the Node
proxy to a Directory
proxy, as well as an uncheckedCast
to narrow the Node
proxy to a File
proxy. Exactly one of those casts will succeed, so there is no need to call checkedCast
twice: if the Node
is-a Directory
, the code uses the DirectoryPrx
returned by the checkedCast
; if the checkedCast
fails, we know that the Node is-a File and, therefore, an uncheckedCast
is sufficient to get a FilePrx
.
uncheckedCast
instead of a checkedCast
because an uncheckedCast
does not incur any network traffic."(directory)"
or "(file)"
following the name.read
operation on the file to retrieve the file contents and then iterates over the returned sequence of lines, printing each line.Assume that we have a small file system consisting of a two files and a directory as follows:
A small file system.
The output produced by the client for this file system is:
{zcode} Contents of root directory: README (file): This file system contains a collection of poetry. Coleridge (directory): Kubla_Khan (file): In Xanadu did Kubla Khan A stately pleasure-dome decree: Where Alph, the sacred river, ran Through caverns measureless to man Down to a sunless sea. {zcode} |
Note that, so far, our client (and server) are not very sophisticated:
We will see how to address these shortcomings in our discussions of IceGrid and object life cycle.