Usync: overview
===============

  Usync is a frontend GUI for the Rsync utility programme of Unix. 

  Usync makes the full power of Rsync available to the non-specialist and 
  makes it easy to dynamically vary the parameters for Rsync and match them 
  to particular situations.

  The GUI (1) hides the quite complicated command-line interface of Rsync, 
  it (2) automates the generation of the "filter file" needed by Rsync to 
  determine the set of files it will consider, and it (3) enhances the 
  presentation of the [l][ResultPanel]list of files[/l] that have been / 
  will be transferred ("[l][DryRun]Dry-run[/l]" command) and thus helps to 
  reduce the risk of false manipulations.

  Rsync remains more powerful than Usync: Usync only provides access to a - 
  quite large - subset of the functions of Rsync. In exchange to this 
  restriction, Usync is easy to use (and the effort for its implementation 
  remains modest): the number of options and of alternatives to be considered 
  is kept at a "reasonable" level.

  The choice of the options implemented in Usync is a consequence of the 
  application for which Usync has been originally designed: the synchronisation 
  of data between hosts on a LAN. The "style" of implementation of Usync makes 
  it easy to accommodate extensions as new application scenarios arrive.

  Ample documentation on the use and configuration of Usync is available 
  through its on-line help facility.



Sample configuration file ($HOME/.usyncrc)
==========================================

  The file sample-.usyncrc is a snapshot of my current .usyncrc. Note that this 
  file assumes that the rsync server on the machine pcharms.unige.ch contains 
  2 modules (common and harms). The /backup/ directory exists on a removable 
  USB drive (I use the default removableMedia string from the app-defaults 
  file), /backup is a soft link to /mnt/removable.

  Normally a .usyncrc file is constructed when a user runs Usync the first 
  time. Usync offers serveral tools for helping with this task.



Format of configuration file
============================

4 paragraphs:
[Version], [ControlVariables], [SyncObjects], [Profiles]

Version paragraph :

	Version=<version-string>	version of generating usync
	Host=<ip-address>		generating host

ControlVariables : list of variables, 1 per line
	<variable-name>=<value>
	    <value>		... current value
   or
	<variable-name>=<val1>,<val2>,<val3>
	    <val1>		... current value
	    <val2>		... column in widget array
	    <val3>		... row in widget array

SyncZones : list of synchronisation zones, 1 per line
	<server>,<client>
	    <server>		... <module>@<ip-address> or <absolute-path>
				    if last char of host= * ... suspended
	    <client>		... <absolute-path>
				    if 1st char of client =  # ... comment
		<module>	... module in the server's /etc/rsyncd.conf
		<ip-address>	... the server's host ip address
		<absolute-path>	... absolute path at the client

Profiles : list of profile definitions. A record consists of an initial line 
				    and - possibly - continuation lines (a 
				    continued line terminates on a backslash)
	<profile-name-string>=<list-of-variables>
	    <list-of-variables>	... <variable>, ... , <variable>
		<variable>	... "<name>=<value>
		    <name>	... tag (label) in conf_descr array
		    <value>	... the corresponding value



Design choices
==============

  Rsync is an excellent and highly flexibile tool. But it is not easy to use, 
  particularly due to the extremely large number of available options. This 
  represents a barrier that makes potential users shy away.

  Usync builds on the achievement of Rsync. It adds a - relatively small - 
  layer of software on top of Rsync which hides its complexity and, where 
  necessary, makes complex aspects (the large number of options) acceptable 
  to the user through the a clearly structured GUI.

  The choice of Tcl/Tk/Expect combines programming ease and efficiency, a 
  nice X-windows look-alike user-interface framework, and a powerfull tool 
  for interfacing the GUI with Rsync.

  The GUI is not compute-intensive - interpretation does not present any 
  efficiency problems. One delicate point is the approach of using Expect 
  and to interpret the output of Rsync by pattern matching: small changes in 
  the implementation of Rsync, respectively the spelling of its output,  
  might create serious problems for Usync, requiring corresponding fixes 
  to be applied. However, the man-pages of Rsync very clearly specify the 
  format of output strings, and it is unlikely that there will be reason to 
  change the documented formats. Practically all pattern matching in Usync is 
  based on such documented strings. During about 3 years of use of a 
  pre-decessor of Usync, no problems have been encountered.



Stability, debugging, extensions
================================

  A predecessor of Usync has been used for synchronising hosts in a small 
  private LAN during 3 years and has been very stable. The upgrade to a 
  general utility has resulted in substantial programme modifications. This 
  has certainly introduced not yet uncovered bugs.

  Usync has been thoroughly tested - but the test in a production environment 
  other than my traditional application can only be made by confronting it 
  to other real-life applications. This will certaily make new bugs pop up. 
  I will do my best to rapidly respond to error reports.

  Not all features of Rsync are accessible through Usync: if new users 
  discover options they imperatively need but that are missing, extensions 
  may become necessary. Usync is very easy to extend, and the way Usync groups 
  and presents option checkbuttons allows for some more features to be added 
  without "messing up" the user interface.
