cpython/Demo/pdist
2000-06-28 14:48:01 +00:00
..
client.py flush before reading response from socket 1995-10-07 19:27:20 +00:00
cmdfw.py renamed to CommandFrameWork 1995-04-27 23:32:47 +00:00
cmptree.py first remote commit test!!! 1995-04-26 22:57:12 +00:00
cvslib.py mac robustness: default timezone, unlink target before rename 1995-10-07 19:25:25 +00:00
cvslock.py initial checkin 1995-06-23 22:03:28 +00:00
FSProxy.py commit -- why not 1995-04-10 11:40:52 +00:00
mac.py mac utility 1996-07-30 19:05:56 +00:00
makechangelog.py nannified 1998-09-14 16:44:15 +00:00
new testing 1995-04-28 13:12:35 +00:00
rcsbump Change #! line to modern usage 1999-03-12 19:05:49 +00:00
rcsclient.py nannified 1998-09-14 16:44:15 +00:00
rcslib.py typos fixed by Rob Hooft 2000-06-28 14:48:01 +00:00
RCSProxy.py nannified 1998-09-14 16:44:15 +00:00
rcvs Change #! line to modern usage 1999-03-12 19:05:49 +00:00
rcvs.py /usr/local/bin/python -> /usr/bin/env python 1996-11-27 19:52:01 +00:00
README restructured index somewhat 1995-06-23 22:11:18 +00:00
rrcs Change #! line to modern usage 1999-03-12 19:05:49 +00:00
rrcs.py /usr/local/bin/python -> /usr/bin/env python 1996-11-27 19:52:01 +00:00
security.py whrandom -> random 1998-05-20 17:13:01 +00:00
server.py import string; add 129.6.64 to security 1995-06-21 02:10:32 +00:00
sumtree.py commit -- why not 1995-04-10 11:40:52 +00:00

Filesystem, RCS and CVS client and server classes
=================================================

*** See the security warning at the end of this file! ***

This directory contains various modules and classes that support
remote file system operations.

CVS stuff
---------

rcvs			Script to put in your bin directory
rcvs.py			Remote CVS client command line interface

cvslib.py		CVS admin files classes (used by rrcs)
cvslock.py		CVS locking algorithms

RCS stuff
---------

rrcs			Script to put in your bin directory
rrcs.py			Remote RCS client command line interface

rcsclient.py		Return an RCSProxyClient instance
			(has reasonable default server/port/directory)

RCSProxy.py		RCS proxy and server classes (on top of rcslib.py)

rcslib.py		Local-only RCS base class (affects stdout &
			local work files)

FSProxy stuff
-------------

sumtree.py		Old demo for FSProxy
cmptree.py		First FSProxy client (used to sync from the Mac)
FSProxy.py		Filesystem interface classes

Generic client/server stuff
---------------------------

client.py		Client class
server.py		Server class

security.py		Security mix-in class (not very secure I think)

Other generic stuff
-------------------

cmdfw.py		CommandFrameWork class
			(used by rcvs, should be used by rrcs as well)


Client/Server operation
-----------------------

The Client and Server classes implement a simple-minded RPC protocol,
using Python's pickle module to transfer arguments, return values and
exceptions with the most generality.  The Server class is instantiated
with a port number on which it should listen for requests; the Client
class is instantiated with a host name and a port number where it
should connect to.  Once a client is connected, a TCP connection is
maintained between client and server.

The Server class currently handles only one connection at a time;
however it could be rewritten to allow various modes of operations,
using multiple threads or processes or the select() system call as
desired to serve multiple clients simultaneously (when using select(),
still handling one request at a time).  This would not require
rewriting of the Client class.  It may also be possible to adapt the
code to use UDP instead of TCP, but then both classes will have to be
rewritten (and unless extensive acknowlegements and request serial
numbers are used, the server should handle duplicate requests, so its
semantics should be idempotent -- shrudder).

Even though the FSProxy and RCSProxy modules define client classes,
the client class is fully generic -- what methods it supports is
determined entirely by the server.  The server class, however, must be
derived from.  This is generally done as follows:

	from server import Server
	from client import Client

	# Define a class that performs the operations locally
	class MyClassLocal:
		def __init__(self): ...
		def _close(self): ...

	# Derive a server class using multiple inheritance
	class MyClassServer(MyClassLocal, Server):
		def __init__(self, address):
			# Must initialize MyClassLocal as well as Server
			MyClassLocal.__init__(self)
			Server.__init__(self, address)
		def _close(self):
			Server._close()
			MyClassLocal._close()

	# A dummy client class
	class MyClassClient(Client): pass

Note that because MyClassLocal isn't used in the definition of
MyClassClient, it would actually be better to place it in a separate
module so the definition of MyClassLocal isn't executed when we only
instantiate a client.

The modules client and server should probably be renamed to Client and
Server in order to match the class names.


*** Security warning: this version requires that you have a file
$HOME/.python_keyfile at the server and client side containing two
comma- separated numbers.  The security system at the moment makes no
guarantees of actuallng being secure -- however it requires that the
key file exists and contains the same numbers at both ends for this to
work.  (You can specify an alternative keyfile in $PYTHON_KEYFILE).
Have a look at the Security class in security.py for details;
basically, if the key file contains (x, y), then the security server
class chooses a random number z (the challenge) in the range
10..100000 and the client must be able to produce pow(z, x, y)
(i.e. z**x mod y).