The first step in creating our Python application is to compile our Slice definition to generate Python proxies and skeletons. You can compile the definition as follows:
1
The slice2py compiler produces a single source file,
Printer_ice.py, from this definition. The compiler also creates a Python package for the
Demo module, resulting in a subdirectory named
Demo. The exact contents of the source file do not concern us for now—it contains the generated code that corresponds to the
Printer interface we defined in
Printer.ice.
To implement our Printer interface, we must create a servant class. By convention, servant classes use the name of their interface with an
I‑suffix, so our servant class is called
PrinterI:
class PrinterI(Demo.Printer):
def printString(self, s, current=None):
print s
The PrinterI class inherits from a base class called
Demo.Printer, which is generated by the
slice2py compiler. The base class is abstract and contains a
printString method that accepts a string for the printer to print and a parameter of type
Ice.Current. (For now we will ignore the
Ice.Current parameter. We will see its purpose in detail in
Section 28.6.) Our implementation of the
printString method simply writes its argument to the terminal.
The remainder of the server code, in Server.py, follows our servant class and is shown in full here:
import sys, traceback, Ice
import Demo
class PrinterI(Demo.Printer):
def printString(self, s, current=None):
print s
status = 0
ic = None
try:
ic = Ice.initialize(sys.argv)
adapter = ic.createObjectAdapterWithEndpoints(
"SimplePrinterAdapter", "default ‑p 10000")
object = PrinterI()
adapter.add(object, ic.stringToIdentity("SimplePrinter"))
adapter.activate()
ic.waitForShutdown()
except:
traceback.print_exc()
status = 1
if ic:
# Clean up
try:
ic.destroy()
except:
traceback.print_exc()
status = 1
sys.exit(status)
status = 0
ic = None
try:
# Server implementation here...
except:
traceback.print_exc()
status = 1
if ic:
# Clean up
try:
ic.destroy()
except:
traceback.print_exc()
status = 1
sys.exit(status)
The body of the main program contains a try block in which we place all the server code, followed by an
except block. The
except block catches all exceptions that may be thrown by the code; the intent is that, if the code encounters an unexpected run-time exception anywhere, the stack is unwound all the way back to the main program, which prints the exception and then returns failure to the operating system.
Before the code exits, it destroys the communicator (if one was created successfully). Doing this is essential in order to correctly finalize the Ice run time: the program
must call
destroy on any communicator it has created; otherwise, undefined behavior results.
The body of our try block contains the actual server code:
ic = Ice.initialize(sys.argv)
adapter = ic.createObjectAdapterWithEndpoints(
"SimplePrinterAdapter", "default ‑p 10000")
object = PrinterI()
adapter.add(object, ic.stringToIdentity("SimplePrinter"))
adapter.activate()
ic.waitForShutdown()
1. We initialize the Ice run time by calling Ice.initialize. (We pass
sys.argv to this call because the server may have command-line arguments that are of interest to the run time; for this example, the server does not require any command-line arguments.) The call to
initialize returns an
Ice::Communicator reference, which is the main handle to the Ice run time.
2.
We create an object adapter by calling createObjectAdapterWithEndpoints on the
Communicator instance. The arguments we pass are
"SimplePrinterAdapter" (which is the name of the adapter) and
"default ‑p 10000", which instructs the adapter to listen for incoming requests using the default protocol (TCP/IP) at port number 10000.
4.
We inform the object adapter of the presence of a new servant by calling add on the adapter; the arguments to
add are the servant we have just instantiated, plus an identifier. In this case, the string
"SimplePrinter" is the name of the servant. (If we had multiple printers, each would have a different name or, more correctly, a different
object identity.)
5.
Next, we activate the adapter by calling its activate method. (The adapter is initially created in a holding state; this is useful if we have many servants that share the same adapter and do not want requests to be processed until after all the servants have been instantiated.)
6.
Finally, we call waitForShutdown. This call suspends the calling thread until the server implementation terminates, either by making a call to shut down the run time, or in response to a signal. (For now, we will simply interrupt the server on the command line when we no longer need it.)
Note that, even though there is quite a bit of code here, that code is essentially the same for all servers. You can put that code into a helper class and, thereafter, will not have to bother with it again. (Ice ships with such a helper class, called
Ice.Application—see
Section 20.3.1.) As far as actual application code is concerned, the server contains only a few lines: three lines for the definition of the
PrinterI class, plus two lines to instantiate a
PrinterI object and register it with the object adapter.
The client code, in Client.py, looks very similar to the server. Here it is in full:
import sys, traceback, Ice
import Demo
status = 0
ic = None
try:
ic = Ice.initialize(sys.argv)
base = ic.stringToProxy("SimplePrinter:default ‑p 10000")
printer = Demo.PrinterPrx.checkedCast(base)
if not printer:
raise RuntimeError("Invalid proxy")
printer.printString("Hello World!")
except:
traceback.print_exc()
status = 1
if ic:
# Clean up
try:
ic.destroy()
except:
traceback.print_exc()
status = 1
sys.exit(status)
Note that the overall code layout is the same as for the server: we use the same try and
except blocks to deal with errors. The code in the
try block does the following:
2.
The next step is to obtain a proxy for the remote printer. We create a proxy by calling
stringToProxy on the communicator, with the string
"SimplePrinter:default ‑p 10000". Note that the string contains the object identity and the port number that were used by the server. (Obviously, hard-coding object identities and port numbers into our applications is a bad idea, but it will do for now; we will see more architecturally sound ways of doing this in
Chapter 35.)
3.
The proxy returned by stringToProxy is of type
Ice::ObjectPrx, which is at the root of the inheritance tree for interfaces and classes. But to actually talk to our printer, we need a proxy for a
Demo::Printer interface, not an
Object interface. To do this, we need to do a down-cast by calling
Demo.PrinterPrx.checkedCast. A checked cast sends a message to the server, effectively asking "is this a proxy for a
Demo::Printer interface?" If so, the call returns a proxy of type
Demo.PrinterPrx; otherwise, if the proxy denotes an interface of some other type, the call returns
None.
The client runs and exits without producing any output; however, in the server window, we see the
"Hello World!" that is produced by the printer. To get rid of the server, we interrupt it on the command line for now. (We will see cleaner ways to terminate a server in
Chapter 20.)
If anything goes wrong, the client will print an error message. For example, if we run the client without having first started the server, we get something like the following:
Traceback (most recent call last):
File "Client.py", line 10, in ?
printer = Demo.PrinterPrx.checkedCast(base)
File "Printer_ice.py", line 43, in checkedCast
return Demo.PrinterPrx.ice_checkedCast(proxy, '::Demo::Printer', facet)
ConnectionRefusedException: Ice.ConnectionRefusedException:
Connection refused
Note that, to successfully run the client and server, the Python interpreter must be able to locate the Ice extension for Python. See the Ice for Python installation instructions for more information.
