Emancipated trunk. Removed tags, branches and cvs stuff.

branches/r0-10/rdiff-backup/TODO

-Update FAQ on cstream
-
-Write some better selection test cases to test new Iterate_fast func.
-
-Work on killtest code - avoid returning a failure when a file is
-simply skipped.
-
----------[ Medium term ]---------------------------------------
-
-Interpret a list of filenames in globbing form
-(--include-globbing-filelist maybe).
-
-Add --dry-run option (target for v1.1.x)
-
-Add # of increments option to --remove-older-than
-
-Restore only changed files
-
-Make argument shortcut for cstream
-
-Make --calculate-averages work with directory_statistics file.
-
----------[ Long term ]---------------------------------------
-
-Think about adding Gaudet's idea for keeping track of renamed files.
-
-Look into different inode generation techniques (see treescan, Dean
-Gaudet's other post).
-
-

branches/r0-10/rdiff-backup/dist/setup.py

-#!/usr/bin/env python
-
-import sys, os, getopt
-from distutils.core import setup, Extension
-
-version_string = "$version"
-
-if sys.version_info[:2] < (2,2):
-	print "Sorry, rdiff-backup requires version 2.2 or later of python"
-	sys.exit(1)
-
-setup(name="rdiff-backup",
-	  version=version_string,
-	  description="Local/remote mirroring+incremental backup",
-	  author="Ben Escoto",
-	  author_email="bescoto@stanford.edu",
-	  url="http://rdiff-backup.stanford.edu",
-	  packages = ['rdiff_backup'],
-	  ext_modules = [Extension("rdiff_backup.C", ["cmodule.c"],
-							   define_macros=[("_LARGEFILE_SOURCE", 1),
-											  ("_FILE_OFFSET_BITS", 64),
-											  ("_LARGE_FILES", 1)]),
-					 Extension("rdiff_backup._librsync",
-							   ["_librsyncmodule.c"],
-							   libraries=["rsync"])],
-	  scripts = ['rdiff-backup'],
-	  data_files = [('share/man/man1', ['rdiff-backup.1']),
-					('share/doc/rdiff-backup-%s' % version_string,
-					 ['CHANGELOG', 'COPYING', 'README', 'FAQ.html'])])
-
-
-

branches/r0-10/rdiff-backup/rdiff-backup

-#!/usr/bin/env python
-# rdiff-backup -- Mirror files while keeping incremental changes
-# Version $version released September 16, 2002
-# Copyright (C) 2001, 2002 Ben Escoto <bescoto@stanford.edu>
-#
-# This program is licensed under the GNU General Public License (GPL).
-# you can redistribute it and/or modify it under the terms of the GNU
-# General Public License as published by the Free Software Foundation,
-# Inc., 675 Mass Ave, Cambridge MA 02139, USA; either version 2 of the
-# License, or (at your option) any later version.  Distributions of
-# rdiff-backup should include a copy of the GPL in a file called
-# COPYING.  The GPL is also available online at
-# http://www.gnu.org/copyleft/gpl.html.
-#
-# See http://rdiff-backup.stanford.edu/ for more information.  Please
-# send mail to me or the mailing list if you find bugs or have any
-# suggestions.
-
-import sys
-import rdiff_backup.Main
-
-if __name__ == "__main__" and not globals().has_key('__no_execute__'):
-	rdiff_backup.Main.Main(sys.argv[1:])
-
-

branches/r0-10/rdiff-backup/rdiff_backup/SetConnections.py

-# Copyright 2002 Ben Escoto
-#
-# This file is part of rdiff-backup.
-#
-# rdiff-backup is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA
-# 02139, USA; either version 2 of the License, or (at your option) any
-# later version; incorporated herein by reference.
-
-"""Parse args and setup connections
-
-The functions in this module are used once by Main to parse file
-descriptions like bescoto@folly.stanford.edu:/usr/bin/ls and to set up
-the related connections.
-
-"""
-
-# This is the schema that determines how rdiff-backup will open a
-# pipe to the remote system.  If the file is given as A::B, %s will
-# be substituted with A in the schema.
-__cmd_schema = 'ssh -C %s rdiff-backup --server'
-__cmd_schema_no_compress = 'ssh %s rdiff-backup --server'
-
-# This is a list of remote commands used to start the connections.
-# The first is None because it is the local connection.
-__conn_remote_cmds = [None]
-
-class SetConnectionsException(Exception): pass
-
-def get_cmd_pairs(arglist, remote_schema = None, remote_cmd = None):
-	"""Map the given file descriptions into command pairs
-
-	Command pairs are tuples cmdpair with length 2.  cmdpair[0] is
-	None iff it describes a local path, and cmdpair[1] is the path.
-
-	"""
-	global __cmd_schema
-	if remote_schema: __cmd_schema = remote_schema
-	elif not Globals.ssh_compression: __cmd_schema = __cmd_schema_no_compress
-
-	if not arglist: return []
-	desc_pairs = map(parse_file_desc, arglist)
-
-	if filter(lambda x: x[0], desc_pairs): # True if any host_info found
-		if remote_cmd:
-			Log.FatalError("The --remote-cmd flag is not compatible "
-						   "with remote file descriptions.")
-	elif remote_schema:
-		Log("Remote schema option ignored - no remote file "
-			"descriptions.", 2)
-	cmdpairs = map(desc2cmd_pairs, desc_pairs)
-	if remote_cmd: # last file description gets remote_cmd
-		cmd_pairs[-1] = (remote_cmd, cmd_pairs[-1][1])
-	return cmdpairs
-
-def cmdpair2rp(cmd_pair):
-	"""Return RPath from cmd_pair (remote_cmd, filename)"""
-	cmd, filename = cmd_pair
-	if cmd: conn = init_connection(cmd)
-	else: conn = Globals.local_connection
-	return RPath(conn, filename)
-
-def desc2cmd_pairs(desc_pair):
-	"""Return pair (remote_cmd, filename) from desc_pair"""
-	host_info, filename = desc_pair
-	if not host_info: return (None, filename)
-	else: return (fill_schema(host_info), filename)
-
-def parse_file_desc(file_desc):
-	"""Parse file description returning pair (host_info, filename)
-
-	In other words, bescoto@folly.stanford.edu::/usr/bin/ls =>
-	("bescoto@folly.stanford.edu", "/usr/bin/ls").  The
-	complication is to allow for quoting of : by a \.  If the
-	string is not separated by :, then the host_info is None.
-
-	"""
-	def check_len(i):
-		if i >= len(file_desc):
-			raise SetConnectionsException(
-				"Unexpected end to file description %s" % file_desc)
-
-	host_info_list, i, last_was_quoted = [], 0, None
-	while 1:
-		if i == len(file_desc):
-			return (None, file_desc)
-
-		if file_desc[i] == '\\':
-			i = i+1
-			check_len(i)
-			last_was_quoted = 1
-		elif (file_desc[i] == ":" and i > 0 and file_desc[i-1] == ":"
-			  and not last_was_quoted):
-			host_info_list.pop() # Remove last colon from name
-			break
-		else: last_was_quoted = None
-		host_info_list.append(file_desc[i])
-		i = i+1
-
-	check_len(i+1)
-	return ("".join(host_info_list), file_desc[i+1:])
-
-def fill_schema(host_info):
-	"""Fills host_info into the schema and returns remote command"""
-	return __cmd_schema % host_info
-
-def init_connection(remote_cmd):
-	"""Run remote_cmd, register connection, and then return it
-
-	If remote_cmd is None, then the local connection will be
-	returned.  This also updates some settings on the remote side,
-	like global settings, its connection number, and verbosity.
-
-	"""
-	if not remote_cmd: return Globals.local_connection
-
-	Log("Executing " + remote_cmd, 4)
-	stdin, stdout = os.popen2(remote_cmd)
-	conn_number = len(Globals.connections)
-	conn = PipeConnection(stdout, stdin, conn_number)
-
-	check_connection_version(conn, remote_cmd)
-	Log("Registering connection %d" % conn_number, 7)
-	init_connection_routing(conn, conn_number, remote_cmd)
-	init_connection_settings(conn)
-	return conn
-
-def check_connection_version(conn, remote_cmd):
-	"""Log warning if connection has different version"""
-	try: remote_version = conn.Globals.get('version')
-	except ConnectionReadError, exception:
-		Log.FatalError("""%s
-
-Couldn't start up the remote connection by executing
-
-    %s
-
-Remember that, under the default settings, rdiff-backup must be
-installed in the PATH on the remote system.  See the man page for more
-information.""" % (exception, remote_cmd))
-		
-	if remote_version != Globals.version:
-		Log("Warning: Local version %s does not match remote version %s."
-			% (Globals.version, remote_version), 2)
-
-def init_connection_routing(conn, conn_number, remote_cmd):
-	"""Called by init_connection, establish routing, conn dict"""
-	Globals.connection_dict[conn_number] = conn
-
-	conn.SetConnections.init_connection_remote(conn_number)
-	for other_remote_conn in Globals.connections[1:]:
-		conn.SetConnections.add_redirected_conn(
-			other_remote_conn.conn_number)
-		other_remote_conn.SetConnections.add_redirected_conn(conn_number)
-
-	Globals.connections.append(conn)
-	__conn_remote_cmds.append(remote_cmd)
-
-def init_connection_settings(conn):
-	"""Tell new conn about log settings and updated globals"""
-	conn.Log.setverbosity(Log.verbosity)
-	conn.Log.setterm_verbosity(Log.term_verbosity)
-	for setting_name in Globals.changed_settings:
-		conn.Globals.set(setting_name, Globals.get(setting_name))
-	FilenameMapping.set_init_quote_vals()
-
-def init_connection_remote(conn_number):
-	"""Run on server side to tell self that have given conn_number"""
-	Globals.connection_number = conn_number
-	Globals.local_connection.conn_number = conn_number
-	Globals.connection_dict[0] = Globals.connections[1]
-	Globals.connection_dict[conn_number] = Globals.local_connection
-
-def add_redirected_conn(conn_number):
-	"""Run on server side - tell about redirected connection"""
-	Globals.connection_dict[conn_number] = \
-		   RedirectedConnection(conn_number)
-
-def UpdateGlobal(setting_name, val):
-	"""Update value of global variable across all connections"""
-	for conn in Globals.connections:
-		conn.Globals.set(setting_name, val)
-
-def BackupInitConnections(reading_conn, writing_conn):
-	"""Backup specific connection initialization"""
-	reading_conn.Globals.set("isbackup_reader", 1)
-	writing_conn.Globals.set("isbackup_writer", 1)
-	UpdateGlobal("backup_reader", reading_conn)
-	UpdateGlobal("backup_writer", writing_conn)
-	if (Globals.change_source_perms and
-		reading_conn.Globals.get("process_uid") == 0):
-		Log("Warning: --change_source_perms should usually not be used when\n"
-			"the reading connection is running as root, because root can\n"
-			"read all files regardless of their permissions.", 2)
-
-def CloseConnections():
-	"""Close all connections.  Run by client"""
-	assert not Globals.server
-	for conn in Globals.connections: conn.quit()
-	del Globals.connections[1:] # Only leave local connection
-	Globals.connection_dict = {0: Globals.local_connection}
-	Globals.backup_reader = Globals.isbackup_reader = \
-		  Globals.backup_writer = Globals.isbackup_writer = None
-
-def TestConnections():
-	"""Test connections, printing results"""
-	if len(Globals.connections) == 1: print "No remote connections specified"
-	else:
-		for i in range(1, len(Globals.connections)): test_connection(i)
-
-def test_connection(conn_number):
-	"""Test connection.  conn_number 0 is the local connection"""
-	print "Testing server started by: ", __conn_remote_cmds[conn_number]
-	conn = Globals.connections[conn_number]
-	try:
-		assert conn.pow(2,3) == 8
-		assert conn.os.path.join("a", "b") == "a/b"
-		version = conn.reval("lambda: Globals.version")
-	except:
-		sys.stderr.write("Server tests failed\n")
-		raise
-	if not version == Globals.version:
-		print """Server may work, but there is a version mismatch:
-Local version: %s
-Remote version: %s""" % (Globals.version, version)
-	else: print "Server OK"
-
-
-from log import *
-from rpath import *
-from connection import *
-import Globals, FilenameMapping
-

branches/r0-10/rdiff-backup/rdiff_backup/cmodule.c

-/* ----------------------------------------------------------------------- *
- *   
- *   Copyright 2002 Ben Escoto
- *
- *   This file is part of rdiff-backup.
- *
- *   rdiff-backup is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License as
- *   published by the Free Software Foundation, Inc., 675 Mass Ave,
- *   Cambridge MA 02139, USA; either version 2 of the License, or (at
- *   your option) any later version; incorporated herein by reference.
- *
- * ----------------------------------------------------------------------- */
-
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <Python.h>
-#include <errno.h>
-
-/* choose the appropriate stat and fstat functions and return structs */
-/* This code taken from Python's posixmodule.c */
-#undef STAT
-#if defined(MS_WIN64) || defined(MS_WIN32)
-#	define STAT _stati64
-#	define FSTAT _fstati64
-#	define STRUCT_STAT struct _stati64
-#else
-#	define STAT stat
-#	define FSTAT fstat
-#	define STRUCT_STAT struct stat
-#endif
-
-static PyObject *UnknownFileTypeError;
-static PyObject *c_make_file_dict(PyObject *self, PyObject *args);
-static PyObject *long2str(PyObject *self, PyObject *args);
-static PyObject *str2long(PyObject *self, PyObject *args);
-
-
-/* Turn a stat structure into a python dictionary.  The preprocessor
-   stuff taken from Python's posixmodule.c */
-static PyObject *c_make_file_dict(self, args)
-	 PyObject *self;
-	 PyObject *args;
-{
-  PyObject *size, *inode, *mtime, *atime, *devloc, *return_val;
-  char *filename, filetype[5];
-  STRUCT_STAT sbuf;
-  long int mode, perms;
-  int res;
-
-  if (!PyArg_ParseTuple(args, "s", &filename)) return NULL;
-
-  Py_BEGIN_ALLOW_THREADS
-  res = lstat(filename, &sbuf);
-  Py_END_ALLOW_THREADS
-
-  if (res != 0) {
-	if (errno == ENOENT || errno == ENOTDIR)
-	  return Py_BuildValue("{s:s}", "type", NULL);
-	else {
-	  PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
-	  return NULL;
-	}
-  }
-#ifdef HAVE_LARGEFILE_SUPPORT
-  size = PyLong_FromLongLong((LONG_LONG)sbuf.st_size);
-  inode = PyLong_FromLongLong((LONG_LONG)sbuf.st_ino);
-#else
-  size = PyInt_FromLong(sbuf.st_size);
-  inode = PyInt_FromLong((long)sbuf.st_ino);
-#endif
-  mode = (long)sbuf.st_mode;
-  perms = mode & 07777;
-#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
-  devloc = PyLong_FromLongLong((LONG_LONG)sbuf.st_dev);
-#else
-  devloc = PyInt_FromLong((long)sbuf.st_dev);
-#endif
-#if SIZEOF_TIME_T > SIZEOF_LONG
-  mtime = PyLong_FromLongLong((LONG_LONG)sbuf.st_mtime);
-  atime = PyLong_FromLongLong((LONG_LONG)sbuf.st_atime);
-#else
-  mtime = PyInt_FromLong((long)sbuf.st_mtime);
-  atime = PyInt_FromLong((long)sbuf.st_atime);
-#endif
-
-  /* Build return dictionary from stat struct */
-  if (S_ISREG(mode) || S_ISDIR(mode) || S_ISSOCK(mode) || S_ISFIFO(mode)) {
-	/* Regular files, directories, sockets, and fifos */
-	if S_ISREG(mode) strcpy(filetype, "reg");
-	else if S_ISDIR(mode) strcpy(filetype, "dir");
-	else if S_ISSOCK(mode) strcpy(filetype, "sock");
-	else strcpy(filetype, "fifo");
-	return_val =  Py_BuildValue("{s:s,s:O,s:l,s:l,s:l,s:O,s:O,s:l,s:O,s:O}",
-								"type", filetype,
-								"size", size,
-								"perms", perms,
-								"uid", (long)sbuf.st_uid,
-								"gid", (long)sbuf.st_gid,
-								"inode", inode,
-								"devloc", devloc,
-								"nlink", (long)sbuf.st_nlink,
-								"mtime", mtime,
-								"atime", atime);
-  } else if S_ISLNK(mode) {
-	/* Symbolic links */
-	char linkname[1024];
-	int len_link = readlink(filename, linkname, 1023);
-	if (len_link < 0) {
-	  PyErr_SetFromErrno(PyExc_OSError);
-	  return_val = NULL;
-	} else {
-	  linkname[len_link] = '\0';
-	  return_val = Py_BuildValue("{s:s,s:O,s:l,s:l,s:l,s:O,s:O,s:l,s:s}",
-								 "type", "sym",
-								 "size", size,
-								 "perms", perms,
-								 "uid", (long)sbuf.st_uid,
-								 "gid", (long)sbuf.st_gid,
-								 "inode", inode,
-								 "devloc", devloc,
-								 "nlink", (long)sbuf.st_nlink,
-								 "linkname", linkname);
-	}
-  } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
-	/* Device files */
-	char devtype[2];
-#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
-	LONG_LONG devnums = (LONG_LONG)sbuf.st_rdev;
-	PyObject *major_num = PyLong_FromLongLong(devnums >> 8);
-#else
-	long int devnums = (long)sbuf.st_dev;
-	PyObject *major_num = PyInt_FromLong(devnums >> 8);
-#endif
-	int minor_num = (int)(devnums & 0xff);
-	if S_ISCHR(mode) strcpy(devtype, "c");
-	else strcpy(devtype, "b");
-	return_val = Py_BuildValue("{s:s,s:O,s:l,s:l,s:l,s:O,s:O,s:l,s:N}",
-							   "type", "dev",
-							   "size", size,
-							   "perms", perms,
-							   "uid", (long)sbuf.st_uid,
-							   "gid", (long)sbuf.st_gid,
-							   "inode", inode,
-							   "devloc", devloc,
-							   "nlink", (long)sbuf.st_nlink,
-							   "devnums", Py_BuildValue("(s,O,i)", devtype,
-														major_num, minor_num));
-	Py_DECREF(major_num);
-  } else {
-	/* Unrecognized file type - raise exception */
-	PyErr_SetString(UnknownFileTypeError, filename);
-	return_val = NULL;
-  }
-  Py_DECREF(size);
-  Py_DECREF(inode);
-  Py_DECREF(devloc);
-  Py_DECREF(mtime);
-  Py_DECREF(atime);
-  return return_val;
-}
-
-
-/* Convert python long into 7 byte string */
-static PyObject *long2str(self, args)
-	 PyObject *self;
-	 PyObject *args;
-{
-  unsigned char s[7];
-  PyLongObject *pylong;
-  PyObject *return_val;
-
-  if (!PyArg_ParseTuple(args, "O!", &PyLong_Type, &pylong)) return NULL;
-  if (_PyLong_AsByteArray(pylong, s, 7, 0, 0) != 0) return NULL;
-  else return Py_BuildValue("s#", s, 7);
-  return return_val;
-}
-
-
-/* Reverse of above; convert 7 byte string into python long */
-static PyObject *str2long(self, args)
-	 PyObject *self;
-	 PyObject *args;
-{
-  unsigned char *s;
-  int ssize;
-
-  if (!PyArg_ParseTuple(args, "s#", &s, &ssize)) return NULL;
-  if (ssize != 7) {
-	PyErr_SetString(PyExc_TypeError, "Single argument must be 7 char string");
-	return NULL;
-  }
-  return _PyLong_FromByteArray(s, 7, 0, 0);
-}
-
-
-static PyMethodDef CMethods[] = {
-  {"make_file_dict", c_make_file_dict, METH_VARARGS,
-   "Make dictionary from file stat"},
-  {"long2str", long2str, METH_VARARGS, "Convert python long to 7 byte string"},
-  {"str2long", str2long, METH_VARARGS, "Convert 7 byte string to python long"},
-  {NULL, NULL, 0, NULL}
-};
-
-void initC(void)
-{
-  PyObject *m, *d;
-
-  m = Py_InitModule("C", CMethods);
-  d = PyModule_GetDict(m);
-  UnknownFileTypeError = PyErr_NewException("C.UnknownFileTypeError",
-											NULL, NULL);
-  PyDict_SetItemString(d, "UnknownFileTypeError", UnknownFileTypeError);
-}
-

branches/r0-10/rdiff-backup/rdiff_backup/compilec.py

-#!/usr/bin/env python
-
-import sys, os
-from distutils.core import setup, Extension
-
-assert len(sys.argv) == 1
-sys.argv.append("build")
-
-setup(name="CModule",
-	  version="0.9.0",
-	  description="rdiff-backup's C component",
-	  ext_modules=[Extension("C", ["cmodule.c"],
-							 define_macros=[("_LARGEFILE_SOURCE", 1),
-											("_FILE_OFFSET_BITS", 64),
-											("_LARGE_FILES", 1)]),
-				   Extension("_librsync",
-							 ["_librsyncmodule.c"],
-							 libraries=["rsync"])])
-
-assert not os.system("mv build/lib.linux-i686-2.2/C.so .")
-assert not os.system("mv build/lib.linux-i686-2.2/_librsync.so .")
-assert not os.system("rm -rf build")

branches/r0-10/rdiff-backup/rdiff_backup/destructive_stepping.py

-# Copyright 2002 Ben Escoto
-#
-# This file is part of rdiff-backup.
-#
-# rdiff-backup is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA
-# 02139, USA; either version 2 of the License, or (at your option) any
-# later version; incorporated herein by reference.
-
-"""Deal with side effects from traversing trees"""
-
-from __future__ import generators
-import types
-from rpath import *
-from lazy import *
-
-
-class DSRPPermError(Exception):
-	"""Exception used when a DSRPath can't get sufficient permissions"""
-	pass
-
-class DSRPath(RPath):
-	"""Destructive Stepping RPath
-
-	Sometimes when we traverse the directory tree, even when we just
-	want to read files, we have to change things, like the permissions
-	of a file or directory in order to read it, or the file's access
-	times.  This class is like an RPath, but the permission and time
-	modifications are delayed, so that they can be done at the very
-	end when they won't be disturbed later.
-
-	Here are the new class variables:
-	delay_perms - true iff future perm changes should be delayed
-	newperms - holds the perm values while they are delayed
-	delay_atime - true iff some atime change are being delayed
-	newatime - holds the new atime
-	delay_mtime - true if some mtime change is being delayed
-	newmtime - holds the new mtime
-
-	"""
-	def __init__(self, source, conn_or_rp, base = 0, index = ()):
-		"""Initialize DSRP
-
-		Source should be true iff the DSRPath is taken from the
-		"source" partition and thus settings like
-		Globals.change_source_perms should be paid attention to.
-
-		If args is [rpath], return the dsrpath equivalent of rpath,
-		otherwise use the same arguments as the RPath initializer.
-
-		"""
-		if base == 0:
-			assert isinstance(conn_or_rp, RPath)
-			RPath.__init__(self, conn_or_rp.conn,
-						   conn_or_rp.base, conn_or_rp.index)
-		else: RPath.__init__(self, conn_or_rp, base, index)
-
-		if source != "bypass":
-			# "bypass" val is used when unpackaging over connection
-			assert source is None or source is 1
-			self.source = source
-			self.set_delays(source)
-			self.set_init_perms(source)
-
-	def set_delays(self, source):
-		"""Delay writing permissions and times where appropriate"""
-		if not source or Globals.change_source_perms:
-			self.delay_perms, self.newperms = 1, None
-		else: self.delay_perms = None
-
-		if Globals.preserve_atime:
-			self.delay_atime = 1
-			# Now get atime right away if possible
-			if self.data.has_key('atime'): self.newatime = self.data['atime']
-			else: self.newatime = None
-		else: self.delay_atime = None
-		
-		if source:
-			self.delay_mtime = None # we'll never change mtime of source file
-		else:
-			self.delay_mtime = 1
-			# Save mtime now for a dir, because it might inadvertantly change
-			if self.isdir(): self.newmtime = self.data['mtime']
-			else: self.newmtime = None
-
-	def set_init_perms(self, source):
-		"""If necessary, change permissions to ensure access"""
-		if self.isreg() and not self.readable():
-			if (source and Globals.change_source_perms or
-				not source and Globals.change_mirror_perms):
-				self.chmod_bypass(0400)
-		elif self.isdir():
-			if source and Globals.change_source_perms:
-				if not self.readable() or not self.executable():
-					self.chmod_bypass(0500)
-			elif not source and Globals.change_mirror_perms:
-				if not self.hasfullperms(): self.chmod_bypass(0700)
-
-	def warn(self, err):
-		Log("Received error '%s' when dealing with file %s, skipping..."
-			% (err, self.path), 1)
-		raise DSRPPermError(self.path)
-
-	def __getstate__(self):
-		"""Return picklable state.  See RPath __getstate__."""
-		assert self.conn is Globals.local_connection # Can't pickle a conn
-		return self.getstatedict()
-
-	def getstatedict(self):
-		"""Return dictionary containing the attributes we can save"""
-		pickle_dict = {}
-		for attrib in ['index', 'data', 'delay_perms', 'newperms',
-					   'delay_atime', 'newatime',
-					   'delay_mtime', 'newmtime',
-					   'path', 'base', 'source']:
-			if self.__dict__.has_key(attrib):
-				pickle_dict[attrib] = self.__dict__[attrib]
-		return pickle_dict
-
-	def __setstate__(self, pickle_dict):
-		"""Set state from object produced by getstate"""
-		self.conn = Globals.local_connection
-		for attrib in pickle_dict.keys():
-			self.__dict__[attrib] = pickle_dict[attrib]
-
-	def chmod(self, permissions):
-		"""Change permissions, delaying if self.perms_delayed is set"""
-		if self.delay_perms: self.newperms = self.data['perms'] = permissions
-		else: RPath.chmod(self, permissions)
-
-	def getperms(self):
-		"""Return dsrp's intended permissions"""
-		if self.delay_perms and self.newperms is not None:
-			return self.newperms
-		else: return self.data['perms']
-
-	def chmod_bypass(self, permissions):
-		"""Change permissions without updating the data dictionary"""
-		self.delay_perms = 1
-		if self.newperms is None: self.newperms = self.getperms()
-		Log("DSRP: Perm bypass %s to %o" % (self.path, permissions), 8)
-		self.conn.os.chmod(self.path, permissions)
-
-	def settime(self, accesstime, modtime):
-		"""Change times, delaying if self.times_delayed is set"""
-		if self.delay_atime: self.newatime = self.data['atime'] = accesstime
-		if self.delay_mtime: self.newmtime = self.data['mtime'] = modtime
-
-		if not self.delay_atime or not self.delay_mtime:
-			RPath.settime(self, accesstime, modtime)
-		
-	def setmtime(self, modtime):
-		"""Change mtime, delaying if self.times_delayed is set"""
-		if self.delay_mtime: self.newmtime = self.data['mtime'] = modtime
-		else: RPath.setmtime(self, modtime)
-
-	def getmtime(self):
-		"""Return dsrp's intended modification time"""
-		if self.delay_mtime and self.newmtime is not None:
-			return self.newmtime
-		else: return self.data['mtime']
-
-	def getatime(self):
-		"""Return dsrp's intended access time"""
-		if self.delay_atime and self.newatime is not None:
-			return self.newatime
-		else: return self.data['atime']
-
-	def write_changes(self):
-		"""Write saved up permission/time changes"""
-		if not self.lstat(): return # File has been deleted in meantime
-
-		if self.delay_perms and self.newperms is not None:
-			Log("Finalizing permissions of dsrp %s to %s" %
-				(self.path, self.newperms), 8)
-			RPath.chmod(self, self.newperms)
-
-		do_atime = self.delay_atime and self.newatime is not None
-		do_mtime = self.delay_mtime and self.newmtime is not None
-		if do_atime and do_mtime:
-			RPath.settime(self, self.newatime, self.newmtime)
-		elif do_atime and not do_mtime:
-			RPath.settime(self, self.newatime, self.getmtime())
-		elif not do_atime and do_mtime:
-			RPath.setmtime(self, self.newmtime)
-
-	def newpath(self, newpath, index = ()):
-		"""Return similar DSRPath but with new path"""
-		return self.__class__(self.source, self.conn, newpath, index)
-
-	def append(self, ext):
-		"""Return similar DSRPath with new extension"""
-		return self.__class__(self.source, self.conn, self.base,
-							  self.index + (ext,))
-
-	def new_index(self, index):
-		"""Return similar DSRPath with new index"""
-		return self.__class__(self.source, self.conn, self.base, index)
-
-
-class DestructiveSteppingFinalizer(ITRBranch):
-		"""Finalizer that can work on an iterator of dsrpaths
-
-		The reason we have to use an IterTreeReducer is that some files
-		should be updated immediately, but for directories we sometimes
-		need to update all the files in the directory before finally
-		coming back to it.
-
-		"""
-		dsrpath = None
-		def start_process(self, index, dsrpath):
-			self.dsrpath = dsrpath
-
-		def end_process(self):
-			if self.dsrpath: self.dsrpath.write_changes()
-
-		def can_fast_process(self, index, dsrpath):
-			return not self.dsrpath.isdir()
-
-		def fast_process(self, index, dsrpath):
-			if self.dsrpath: self.dsrpath.write_changes()
-
-
-from log import *
-from robust import *
-import Globals

branches/r0-10/rdiff-backup/rdiff_backup/log.py

-# Copyright 2002 Ben Escoto
-#
-# This file is part of rdiff-backup.
-#
-# rdiff-backup is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA
-# 02139, USA; either version 2 of the License, or (at your option) any
-# later version; incorporated herein by reference.
-
-"""Manage logging, displaying and recording messages with required verbosity"""
-
-import time, sys, traceback, types
-
-
-class LoggerError(Exception): pass
-
-class Logger:
-	"""All functions which deal with logging"""
-	def __init__(self):
-		self.log_file_open = None
-		self.log_file_local = None
-		self.verbosity = self.term_verbosity = 3
-		# termverbset is true if the term_verbosity has been explicity set
-		self.termverbset = None
-
-	def setverbosity(self, verbosity_string):
-		"""Set verbosity levels.  Takes a number string"""
-		try: self.verbosity = int(verbosity_string)
-		except ValueError:
-			Log.FatalError("Verbosity must be a number, received '%s' "
-						   "instead." % verbosity_string)
-		if not self.termverbset: self.term_verbosity = self.verbosity
-
-	def setterm_verbosity(self, termverb_string):
-		"""Set verbosity to terminal.  Takes a number string"""
-		try: self.term_verbosity = int(termverb_string)
-		except ValueError:
-			Log.FatalError("Terminal verbosity must be a number, received "
-						   "'%s' insteaxd." % termverb_string)
-		self.termverbset = 1
-
-	def open_logfile(self, rpath):
-		"""Inform all connections of an open logfile.
-
-		rpath.conn will write to the file, and the others will pass
-		write commands off to it.
-
-		"""
-		assert not self.log_file_open
-		for conn in Globals.connections:
-			conn.Log.open_logfile_allconn(rpath.conn)
-		rpath.conn.Log.open_logfile_local(rpath)
-
-	def open_logfile_allconn(self, log_file_conn):
-		"""Run on all connections to signal log file is open"""
-		self.log_file_open = 1
-		self.log_file_conn = log_file_conn
-
-	def open_logfile_local(self, rpath):
-		"""Open logfile locally - should only be run on one connection"""
-		assert self.log_file_conn is Globals.local_connection
-		self.log_file_local = 1
-		self.logrp = rpath
-		self.logfp = rpath.open("a")
-
-	def close_logfile(self):
-		"""Close logfile and inform all connections"""
-		if self.log_file_open:
-			for conn in Globals.connections:
-				conn.Log.close_logfile_allconn()
-			self.log_file_conn.Log.close_logfile_local()
-
-	def close_logfile_allconn(self):
-		"""Run on every connection"""
-		self.log_file_open = None
-
-	def close_logfile_local(self):
-		"""Run by logging connection - close logfile"""
-		assert self.log_file_conn is Globals.local_connection
-		assert not self.logfp.close()
-		self.log_file_local = None
-
-	def format(self, message, verbosity):
-		"""Format the message, possibly adding date information"""
-		if verbosity < 9: return message + "\n"
-		else: return "%s  %s\n" % (time.asctime(time.localtime(time.time())),
-								   message)
-
-	def __call__(self, message, verbosity):
-		"""Log message that has verbosity importance
-
-		message can be a string, which is logged as-is, or a function,
-		which is then called and should return the string to be
-		logged.  We do it this way in case producing the string would
-		take a significant amount of CPU.
-		
-		"""
-		if verbosity > self.verbosity and verbosity > self.term_verbosity:
-			return
-
-		if not type(message) is types.StringType:
-			assert type(message) is types.FunctionType
-			message = message()
-
-		if verbosity <= self.verbosity: self.log_to_file(message)
-		if verbosity <= self.term_verbosity:
-			self.log_to_term(message, verbosity)
-
-	def log_to_file(self, message):
-		"""Write the message to the log file, if possible"""
-		if self.log_file_open:
-			if self.log_file_local:
-				self.logfp.write(self.format(message, self.verbosity))
-			else: self.log_file_conn.Log.log_to_file(message)
-
-	def log_to_term(self, message, verbosity):
-		"""Write message to stdout/stderr"""
-		if verbosity <= 2 or Globals.server: termfp = sys.stderr
-		else: termfp = sys.stdout
-		termfp.write(self.format(message, self.term_verbosity))
-
-	def conn(self, direction, result, req_num):
-		"""Log some data on the connection
-
-		The main worry with this function is that something in here
-		will create more network traffic, which will spiral to
-		infinite regress.  So, for instance, logging must only be done
-		to the terminal, because otherwise the log file may be remote.
-
-		"""
-		if self.term_verbosity < 9: return
-		if type(result) is types.StringType: result_repr = repr(result)
-		else: result_repr = str(result)
-		if Globals.server: conn_str = "Server"
-		else: conn_str = "Client"
-		self.log_to_term("%s %s (%d): %s" %
-						 (conn_str, direction, req_num, result_repr), 9)
-
-	def FatalError(self, message):
-		self("Fatal Error: " + message, 1)
-		Main.cleanup()
-		sys.exit(1)
-
-	def exception_to_string(self):
-		"""Return string version of current exception"""
-		type, value, tb = sys.exc_info()
-		return ("Exception '%s' raised of class '%s':\n%s" %
-				(value, type, "".join(traceback.format_tb(tb))))
-
-	def exception(self, only_terminal = 0, verbosity = 5):
-		"""Log an exception and traceback
-
-		If only_terminal is None, log normally.  If it is 1, then only
-		log to disk if log file is local (self.log_file_open = 1).  If
-		it is 2, don't log to disk at all.
-
-		"""
-		assert only_terminal in (0, 1, 2)
-		if (only_terminal == 0 or
-			(only_terminal == 1 and self.log_file_open)):
-			logging_func = self.__call__
-		else: logging_func = self.log_to_term
-
-		logging_func(self.exception_to_string(), verbosity)
-
-Log = Logger()
-import Globals, Main

branches/r0-10/rdiff-backup/src/compilec.py

-#!/usr/bin/env python
-
-import sys, os
-from distutils.core import setup, Extension
-
-assert len(sys.argv) == 1
-sys.argv.append("build")
-
-setup(name="CModule",
-	  version="0.9.0",
-	  description="rdiff-backup's C component",
-	  ext_modules=[Extension("C", ["cmodule.c"],
-							 define_macros=[("_LARGEFILE_SOURCE", 1),
-											("_FILE_OFFSET_BITS", 64),
-											("_LARGE_FILES", 1)]),
-				   Extension("_librsync",
-							 ["_librsyncmodule.c"],
-							 libraries=["rsync"])])
-
-assert not os.system("mv build/lib.linux-i686-2.2/C.so .")
-assert not os.system("mv build/lib.linux-i686-2.2/_librsync.so .")
-assert not os.system("rm -rf build")

branches/r0-6/rdiff-backup/README

-Thank you for trying rdiff-backup.
-
-Remember that you must have Python 2.2 or later and librsync installed
-(this means that "python" and "rdiff" should be in your path).  To
-download, see http://www.python.org and
-http://sourceforge.net/projects/rproxy/ respectively.
-
-For remote operation, rdiff-backup should be in installed and in the
-PATH on remote system(s) (see man page for more information).
-
-
-If you have the above installed, and it still doesn't work, contact
-Ben Escoto <bescoto@stanford.edu>, or post to the mailing list (see
-web page at http://www.stanford.edu/~bescoto/rdiff-backup for more
-information).
-

branches/r0-6/rdiff-backup/TODO

-Accept a list of files??
-
-Security audit
-
-hardlinks
-
-Don't produce stack trace which looks like crash/include file name in
-logging stats

branches/r0-6/rdiff-backup/dist/makerpm

-#!/usr/bin/env python
-
-import os, sys, re
-
-def GetVersion():
-	"""Return version string by reading in ./rdiff-backup"""
-	fp = open("rdiff-backup", "r")
-	match = re.search("Version (.*?) ", fp.read())
-	fp.close()
-	return match.group(1)
-
-
-if len(sys.argv) == 1:
-	specfile = "rdiff-backup-%s-1.spec" % GetVersion()
-	print "Using specfile %s" % specfile
-elif len(sys.argv) == 2:
-	specfile = sys.argv[1]
-	print "Using specfile %s" % specfile
-else:
-	print ("%s takes zero or one argument, the name of the rpm spec "
-		   "file" % sys.argv[0])
-	sys.exit(1)
-
-base = ".".join(specfile.split(".")[:-1])
-srcrpm = base+".src.rpm"
-noarchrpm = base+".noarch.rpm"
-tarfile = "-".join(base.split("-")[:-1]) + ".tar.gz"
-
-os.system("install -o root -g root -m 644 %s /usr/src/redhat/SOURCES" %
-		  tarfile)
-os.system("rpm -ba --sign -vv --target noarch " + specfile)
-#os.system("install -o ben -g ben -m 644 /usr/src/redhat/SRPMS/%s ." % srcrpm)
-os.system("install -o ben -g ben -m 644 /usr/src/redhat/RPMS/noarch/%s ." %
-		  noarchrpm)