dvcs-autosync-0.5/0000755000000000000000000000000011625302736011053 5ustar dvcs-autosync-0.5/.autosync-example0000644000000000000000000001244411625302736014357 0ustar [autosync] path = ~/amw # If pidfile is not explicitly specified, the name of the used config file # will be appended with '.pid', e.g. for a config file ~/.autosync, the PID # will be written to ~/.autosync.pid. This option allows to override the # default. #pidfile = ~/.autosync.pid # Available synchronization methods: "xmpp" and "none", "autosync-server" # may be implemented later (to potentially be interoperable with SparkleShare). # If xmpp is set as synchronization method, a config section [xmpp] with at # least two config variables username and password must exist, otherwise # dvcs-autosync will fail to start. #syncmethod = none #syncmethod = autosync-server syncmethod = xmpp # Available notification methods: "desktop", "xmpp", "all", and "none". # Default if not specified is "desktop" and indicates that KDE/Gnome/notify # notifications (typically in the tray area) should be used to inform the user # when anything noticable happens. "none" disables notifications altogether # and "xmpp" causes notifications to be sent via XMPP to the account specified # in the "alsonotify" option in section [xmpp]. "all" will send notifications # to both desktop and xmpp. notifymethod = all # There are currently two options for handling file notifications, as neither # one is perfect. You can choose between the 'conservative' option, which is # slower but should work in every corner case, and the 'optimized' option, # which will consume less CPU and I/O resources on a remotely-triggered pull, # but may miss local changes until the next time autosync is restarted or a # manual commit is done on the repository. # # The problem is that during a pull from the remote repository, changes will # be applied to the local file system and consequently generate file-changed # events. These events are in turn translated to add/remove/move commands for # the DVCS, which would duplicate the remote changes locally in the history and # obviously doesn't work e.g. for file removes. Therefore, the file/dir changes # caused by a remote pull must not be translated to local DVCS changes. # The conservative strategy solves this problem by completely suspending event # handling while the pull is active. Because it is possible that _real_ local # changes occur concurrently to the pull, the startup command will be run after # the pull has been finished and event processing was resumed again. This is a # safe option, as all local changes that occurred before or during the pull # will be picked up by the DVCS client. However, when no local changes occurred # (which is more probable), then this strategy causes unnecessary I/O overhead. # # The optimized strategy also suspends the execution of local DVCS actions # triggered by file/directory events during the pull, but does not completely # discard them. Instead, all events that occurred during the pull are recorded # in an event queue which is replayed after the pull has finished. The # advantage is that a complete re-scan of the local repository is avoided and # only those files/directories that saw some modification are re-checked for # local changes. The disadvantage is that this depends more strongly on the # change detection capabilities (trivial ones done by autosync-dvcs and more # complex ones done by the respective DVCS client) and it is therefore not # guaranteed that all local, concurrent changes are being detected. This option # is still being evaluated for corner cases where it doesn't work, and # therefore is not yet the default strategy. pulllock = conservative #pulllock = optimized # The number of seconds to wait for additional events before acting. Setting # this lower will increase the synchronization speed at the cost of CPU and # transfer resources. readfrequency = 5 ignorepath = .git .svn .hg src/packages src/java/openuat src/csharp/sparkleshare src/cpp/cross/keepassx src/android/ipv6config # Note: addcmd, rmcmd, and modifycmd take one argument, movecmd takes two (first the source, then the destination). # Note: statuscmd should return with code 0 when nothing has changed in the # local checked-out tree that needs to be committed and non-zero when a commit # is required. # Note: commitcmd also takes one argument, which will be substituted by a generated commit message. [dvcs] # for git statuscmd = git status | grep -iq "nothing to commit" addcmd = git add %s rmcmd = git rm -r %s modifycmd = git add %s # doesn't work when the source file no longer exists, git expects to move it itself #movecmd = git mv %s %s # use this instead, git will figure out that it was a move because the file is similar movecmd = git rm %s git add %s startupcmd = git add -A commitcmd = git commit -m %s pushcmd = git push pullcmd = git pull remoteurlcmd = git config --get remote.origin.url # for mercurial # next line works with bash as shell, returning 0 if nothing has changed #statuscmd = test "`hg status`" = "" #addcmd = hg add #rmcmd = hg remove #modifycmd = #movecmd = hg mv %s %s #startupcmd = hg addremove #commitcmd = hg commit -m %s #pushcmd = hg push #pullcmd = hg pull -u #remoteurlcmd = hg showconfig paths.default [xmpp] username = your XMPP id here password = your XMPP password here alsonotify = if set, another XMPP id that will get notified when something happens [autosync-server] server = http://whatever.sync.server username = your-username password = your-password dvcs-autosync-0.5/.autosync-example-windows0000644000000000000000000000771011625302736016047 0ustar [autosync] path = ~/Desktop/splashbin pidfile = ~/.autosync.pid syncmethod = xmpp #syncmethod = autosync-server # There are currently two options for handling file notifications, as neither # one is perfect. You can choose between the 'conservative' option, which is # slower but should work in every corner case, and the 'optimized' option, # which will consume less CPU and I/O resources on a remotely-triggered pull, # but may miss local changes until the next time autosync is restarted or a # manual commit is done on the repository. # # The problem is that during a pull from the remote repository, changes will # be applied to the local file system and consequently generate file-changed # events. These events are in turn translated to add/remove/move commands for # the DVCS, which would duplicate the remote changes locally in the history and # obviously doesn't work e.g. for file removes. Therefore, the file/dir changes # caused by a remote pull must not be translated to local DVCS changes. # The conservative strategy solves this problem by completely suspending event # handling while the pull is active. Because it is possible that _real_ local # changes occur concurrently to the pull, the startup command will be run after # the pull has been finished and event processing was resumed again. This is a # safe option, as all local changes that occurred before or during the pull # will be picked up by the DVCS client. However, when no local changes occurred # (which is more probable), then this strategy causes unnecessary I/O overhead. # # The optimized strategy also suspends the execution of local DVCS actions # triggered by file/directory events during the pull, but does not completely # discard them. Instead, all events that occurred during the pull are recorded # in an event queue which is replayed after the pull has finished. The # advantage is that a complete re-scan of the local repository is avoided and # only those files/directories that saw some modification are re-checked for # local changes. The disadvantage is that this depends more strongly on the # change detection capabilities (trivial ones done by autosync-dvcs and more # complex ones done by the respective DVCS client) and it is therefore not # guaranteed that all local, concurrent changes are being detected. This option # is still being evaluated for corner cases where it doesn't work, and # therefore is not yet the default strategy. pulllock = conservative #pulllock = optimized # The number of seconds to wait for additional events before acting. Setting # this lower will increase the synchronization speed at the cost of CPU and # transfer resources. readfrequency = 5 ignorepath = .git # Note: addcmd, rmcmd, and modifycmd take one argument, movecmd takes two (first the source, then the destination). # Note: statuscmd should return with code 0 when nothing has changed in the # local checked-out tree that needs to be committed and non-zero when a commit # is required. # Note: commitcmd also takes one argument, which will be substituted by a generated commit message. [dvcs] # for git statuscmd = git.cmd status | find /I "nothing to commit" addcmd = git.cmd add %s rmcmd = git.cmd rm %s modifycmd = git.cmd add %s # doesn't work when the source file no longer exists, git expects to move it itself #movecmd = git mv %s %s # use this instead, git will figure out that it was a move because the file is similar movecmd = git.cmd rm %s git.cmd add %s startupcmd = git.cmd add -A commitcmd = git.cmd commit -m %s pushcmd = git.cmd push pullcmd = git.cmd pull remoteurlcmd = git.cmd config --get remote.origin.url # for mercurial #statuscmd = hg status #addcmd = hg add #rmcmd = hg remove #modifycmd = #movecmd = hg mv %s %s #startupcmd = hg addremove #commitcmd = hg commit -m %s #pushcmd = hg push #pullcmd = hg pull -u [xmpp] username = ascii158-autosync@jabber.org password = computer alsonotify = [autosync-server] server = http://whatever.sync.server username = your-username password = your-password dvcs-autosync-0.5/.gitignore0000644000000000000000000000032711625302736013045 0ustar *~ .~lock.*# *.backup *.old *.aux *.blg *.bbl *.bib.bak *.pyc .swp.* qt_temp.* build debian/python-module-stampdir/ debian/files debian/dvcs-autosync/ debian/dvcs-autosync.substvars debian/dvcs-autosync.*debhelper* dvcs-autosync-0.5/.project0000644000000000000000000000055711625302736012531 0ustar dvcs-autosync org.python.pydev.PyDevBuilder org.python.pydev.pythonNature dvcs-autosync-0.5/.pydevproject0000644000000000000000000000046011625302736013572 0ustar Default python 2.6 dvcs-autosync-0.5/.settings/0000755000000000000000000000000011625302736012771 5ustar dvcs-autosync-0.5/.settings/org.eclipse.core.resources.prefs0000644000000000000000000000016611625302736021207 0ustar #Thu May 12 17:31:06 CEST 2011 eclipse.preferences.version=1 encoding/dvcs-autosync=utf-8 encoding/jabberbot.py=utf-8 dvcs-autosync-0.5/CHANGELOG0000644000000000000000000000141211625302736012263 0ustar Version 0.5 * Added Windows and Mac OS/X ports (thanks to Philipp Tölke and Olivier Guerriat, respectively, for the ports!). * Added icon for notification popups (patch by evgeni@golov.de via Gitorious, thanks!). Version 0.4 * Debian packaging. * Improved logging and notifications contributed by Dieter Plaetinck. * Added improvements by René 'Necoro' Neumann to make the embedded Jabberbot more stable with regards to reconnections. Instead of running a tight loop while trying to reconnect, ping the server regularly and queue the messages until the connection can be re-established. * Support configurable notifications (desktop notifications, XMPP, all, or none). Version 0.3 * First public release, announced on vcs-home@lists.madduck.net. dvcs-autosync-0.5/COPYRIGHT0000644000000000000000000000040311625302736012343 0ustar # Copyright Rene Mayrhofer, 2010-2011 # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2 or 3 of the License. dvcs-autosync-0.5/INSTALL_MAC0000644000000000000000000000224211625302736012564 0ustar Install dvcs-autosync ------------------------ * `git://gitorious.org/~olivierg/dvcs-autosync/olivierg-dvcs-autosync.git` * `cd olivierg-dvcs-autosync` * `python setup.py build` * `sudo python setup.py install` * `cp .autosync-example ~/.autosync` * `open ~/.autosync` * the config file will open in your default text editor, fill and save it Install xmpppy ------------------------ * Download the latest version here : http://xmpppy.sourceforge.net/ * Untar & `cd` to its folder * `sudo python setup.py install` Install MacFSEvents ------------------------ * `git clone https://github.com/malthe/macfsevents.git` * `cd macfsevents` * `sudo python setup.py install` Install Growl python binding ------------------------ * Make sure you have Growl installed (or install it from growl.info) * `cd` to `growl-python` folder of this repository (or download the Growl SDK on growl.info) * `sudo python setup.py install` * After the first launch, you will be able to configure (or disable) notifications in the Growl preferences pane. Run dvcs-autosync ------------------------ * foreground : `dvcs-autosync` * background : `screen -dmS autosync dvcs-autosync` dvcs-autosync-0.5/README0000644000000000000000000001777411625302736011753 0ustar What does it do? ------------------------ Automatically keep DVCS repositories in sync whenever changes happen by automatically committing and pushing/pulling. How does it do it? ------------------------ 0. Set up desktop notifications (for these nice bubble-style popups when anything happens) and log into a Jabber/XMPP account specified in the config file. 1. Monitor a specific path (and its subdirectories) for changes with inotify. At the moment, only one path is supported and multiple script instances have to be run for multiple disjoint paths. This path is assumed to be (part of) a repository. Currently tested with git, but should support most DVCS (the config file allows to specify the DVCS commands called when interacting with it). Optionally, an [ignores] file is read with one exclusion pattern per line and files matching any of the patterns are ignored. This will typically be the .gitignore file already existing the git tree. 2. When changes are detected, check them into the repository that is being monitored (or delete, or move, etc.). It automatically ignores any patterns listed in .gitignore and the config file allows to exclude other directories (e.g. repositories within the main repository). 3. Wait for a configurable time. When nothing else changes in between, commit. 4. Wait a few seconds longer (again configurable) and, if nothing else is commited, initiate a push. 5. After the push has finished, send an XMPP message to self (that is, to all clients logged in with the same account) to notify other accounts of the push. Furthermore: * At any time in between, when receiving a proper XMPP message, pull from the repository. * A PID file is written to [pidfile] for killing the daemon later on. Dependencies ----------------------- * Python >= 2.6 * patched JabberBot (>= 0.9) (included in this repository) the patch allows reception of messages from its own XMPP id (patch already pushed upstream and will be included in next upstream JabberBot version) * xmpppy (http://xmpppy.sourceforge.net/) Linux: * Linux kernel with inotify enabled * Pyinotify (better performance with version >= 0.9) Mac OS X: * MacFSEvents (https://github.com/malthe/macfsevents/) * Python 2.7 (included in Lion) Recommended: * Pynotify (for desktop notifications on linux) * Growl python binding (for desktop notifications on Mac OS X, included in this repository) Installation ------------------------ (on Mac OS X, see INSTALL_MAC file for detailled instructions) [PREFERRED] PACKAGE INSTALLATION * Either install the Debian package (generated by dpkg-buildpackage from the source tree) or use the arch package * or (on other systems) simply execute (to install to /usr/local/bin and /usr/share/dvcs-autosync): 1. python setup.py build 2. sudo python setup.by install MANUAL INSTALLATION * Copy dvcs-autosync to a location in $PATH and jabberbot.py to a location in $PYTHONPATH * (Quick and dirty: keep both in the same directory and run ./dvcs-autosync later) Create the repository and do initial push ---------------------- [on the server used to host the central git repository] $ git init --bare autosync.git [on the first host using that repository] $ cd ~ && git clone :autosync.git autosync $ cd autosync $ [ populate initial contents and add to index ] $ git commit -m 'Initial commit' $ git push origin master [on each additional host] $ git clone :autosync.git autosync Note that these are only examples. You can use arbitrary directories and repositories. Configuration ----------------------- * Create an XMPP/Jabber account (for example on jabber.org, or set up your own server) * Copy the included .autosync-example config file to ~/.autosync (or wherever you want) * Change it to your needs Running the program ----------------------- autosync.py [config file] # config defaults to ~/.autosync Potential pitfalls ---------------------- * for Jabber login, there probably needs to be a _xmpp-client._tcp. SRV entry in DNS so that the Python XMPP module can look up the server and port to use. Without such an SRV entry, Jabber login may fail even if the account details are correct and the server is reachable. * when there are errors ERROR:pyinotify:add_watch: cannot watch ... on startup, it will either be an invalid file or directory name which can not be watched for changes, or the number of files a user may watch concurrently using the kernel inotify interface has reached the set limit. In the latter case, the limit can be changed by modifying the sysctl variable fs.inotify.max_user_watches and increasing it to a sufficient value (e.g. 500000). * Note that, when keeping changing media files (or other large binaries) in an automatically synchronized repository, it may grow quickly. In the current version, dvcs-autosync will never delete any history and keep all previous versions. This is intentional for documents and text files, but may be problematic for large binaries. I will try to address this problem in future versions, e.g. by integrating with git-annex (see TODO). Thoughts that should be considered at some point but have not yet been implemented: ------------------------ - The XMPP push message already contains a parameter, namely the repository the push went to. Add another parameter to specify the repository in which the change happened so that others can try to pull directly from there, in case it is quicker. The main use case for this optimization is my standard one: the laptop sitting next to the desktop and both of them syncing each other's home directories. Going via the main, hosted server is quite a bit more inefficient than pulling via 1GB/s LAN.... - Pulls and pushes can and should be optimized. At the moment, I take a conservative locking approach whenever a conflict may occur and performance is reasonable on my main work tree with ca. 16GB (cloned GIT repo), but not stellar. Specifically, actually implement the "optimized" pull lock strategy already described in the example config file. - Implement another option for synchronization besides XMPP (idea: a simple broadcast reflector on a single TCP port that could even run on e.g. OpenWRT, or re-use whatever the Sparkleshare server does). - Automatically adding some context to each commit message besides the automatic date/time would be useful for finding out why a change happened. Nepomuk anybody (just kidding, maybe, for now...)? - Allow to specify commit messages via popups. When ignored, use default commit message. Disclaimer ------------------------ This is my first Python program that is longer than 100 lines. Please be easy on me with the patches, complaints and "what did you think, doing it this way?" messages. I have tried to comment wherever I found it necessary for my own understanding, but this is neither the best structured nor the most elegant program I ever wrote. Any hints for improving it are greatly welcome, and interoperability patches to work with Sparkleshare even more so. In the future, the two projects should definitely interoperate, which will come done to implementing each other's notification mechanism. My autosync Python script could then be used wherever headless operation might be required and/or Mono is not installed. I have tested it between three systems and, in this version, it works reasonably well. However, there does seem to be the occasional kink when editors go crazy on temporary file creation, renaming, deleting originals, etc. These might be races, but I don't know for certain yet. Additional test cases are more then welcome. This script should be fairly safe to try, considering that the worst it will do is add a few hundred commits to your DVCS repo and push them to the configured default remote. But, after all, what is the point in using a DVCS if you can't roll back any changes made by you or a buggy script (yes, I did have to do that a number of times while developing the manual inotify event coalescing to cooperate better with git add/remove/mv actions). Rene Mayrhofer dvcs-autosync-0.5/TODO0000644000000000000000000000624111625302736011546 0ustar =============================================================================== This document should be modified to reflect the current state of development. =============================================================================== TODO - currently known bugs: ---------------------------- * Moving directories is not tracked properly with the current event coalescing. Find out how to do a directory move in a better way or simply pass the "-r" option to git when working on directories. * definitely coalesce multiple file events within a time window instead of creating one commit for each file, e.g. when moving whole directory hierarchies (don't clutter the commit history with each file commit separately) * find out why the Jabber msg-to-self doesn't work in some cases * Mac OS X : git pull file manipulation are tracked and cause false "local change" alerts (stopped by git which says "no modification") TODO - short term: ------------------ * autocommit messages should not only include the file path, but also the action performed on the file (as many details as could be helpful for later analysis) * determine if pulling directly from those repositories which caused the changes is quicker then from central * optimize pulls and pushes during startup * implement optimistic pull lock for better performance * Find a good combination of global and file-based event coalescing. This would allow quick synchronization of files that are written and then not touched again while commits to files that are continiously being worked on would be kept in one (larger) commit. There are (at least) 2 use cases to take into account: copying/moving/removing whole directories that should be kept in one big commit and synced quickly, and one file being open in an editor application and being written to more or less continuously. In the latter case, we need to find a compromise between too many commits and to few (which is a problem when accidentally deleting text that was written an hour earlier and that should be recoverable). TODO - future versions: ----------------------- * automatically add some context to commit messages (e.g. location, applications open at the same time, etc.) * allow to specify a commit/change message via traybar icon/popup message, maybe even in retrospect (rewriting history before pushing with a longer push delay) * integrate with git-annex to support keeping large binary files in synchronized directories without unnecessarily increasing repository size by keeping their history Ideas: ------ One approach to the local/global coalescing compromise would be to put all files that are changed within seconds into a waiting list for the event processing. Then, keep a time with each file to remember when the last change was. When files have not been changed for seconds, move them into a "pending commit" list. When the number of files in the "pending commit" list becomes large (with some threshold) and the remaining still-being-written-to files list becomes small and (that's the important part) _stable_ (in terms of no longer adding/removing new files), then break them into two groups, make a commit of the pending list and keep the other files until they settle down. dvcs-autosync-0.5/autosync-xdg-launcher.sh0000755000000000000000000000067711625302736015650 0ustar #!/bin/bash # This simple script will start autosync.py daemons for all configs found in $XDG_CONF_HOME/autosync/, # stopping any existing daemons with that config first. conf=${XDG_CONF_HOME:-$HOME/.config}/autosync data=${XDG_DATA_HOME:-$HOME/.local/share}/autosync mkdir -p $data/log for i in $conf/* do pkill -f "python.*dvcs-autosync .*autosync/$(basename $i)" dvcs-autosync $i &> $data/log/$(basename $i).$(date '+%F-%T').log & done dvcs-autosync-0.5/debian/0000755000000000000000000000000011625302736012275 5ustar dvcs-autosync-0.5/debian/changelog0000644000000000000000000000100211625302736014140 0ustar dvcs-autosync (0.5) unstable; urgency=low * Added icon for dvcs-autosync for pynotify (notification 'bubbles') * Bump standards version and fix Git repo URL to the anonymous version. Closes: #637387: dvcs-autosync: specified Vcs-git is not public accessible -- René Mayrhofer Wed, 24 Aug 2011 22:15:33 +0200 dvcs-autosync (0.4) unstable; urgency=low * Initial release (Closes: #620962: ITP: dvcs-autosync) -- Rene Mayrhofer Tue, 24 May 2011 14:40:12 +0100 dvcs-autosync-0.5/debian/compat0000644000000000000000000000000211625302736013473 0ustar 7 dvcs-autosync-0.5/debian/control0000644000000000000000000000304111625302736013676 0ustar Source: dvcs-autosync Section: utils Priority: optional Maintainer: Rene Mayrhofer Build-Depends: cdbs (>= 0.4.49), debhelper (>= 7.0.50~), python-support, git Standards-Version: 3.9.2 Homepage: http://www.mayrhofer.eu.org/dvcs-autosync Vcs-Git: git://gitorious.org/dvcs-autosync/dvcs-autosync.git Vcs-Browser: http://gitorious.org/dvcs-autosync Package: dvcs-autosync Architecture: all Depends: ${shlibs:Depends}, ${misc:Depends}, ${python:Depends}, python-pyinotify, python-xmpp Recommends: python-notify Description: Automatically synchronize distributed version control repositories dvcs-autosync is an open source replacement for Dropbox/Wuala/Box.net/etc. based on distributed version control systems (DVCS). It offers nearly instantaneous mutual updates when a file is added or changed on one side but with the added benefit of (local, distributed) versioning and that it does not rely on a centralized service provider, but can be used with any DVCS hosting option including a completely separate server. . Synchronization of directories is based on DVCS repositories. Git is used for main development and is being tested most thoroughly as the backend storage, but other DVCS such as Mercurial are also supported. dvcs-autosync is comparable to SparkleShare in terms of overall aim, but takes a more minimalistic approach. A single Python script monitors the configured directory for live changes, commits these changes to the DVCS (such as git) and synchronizes with other instances using XMPP messages. dvcs-autosync-0.5/debian/copyright0000644000000000000000000000102611625302736014227 0ustar This work was packaged for Debian by: Rene Mayrhofer on Sat, 19 Mar 2011 22:50:12 +0100 It was downloaded from: http://www.mayrhofer.eu.org/dvcs-autosync Upstream Author(s): Rene Mayrhofer Copyright: Copyright (C) 2011 Rene Mayrhofer License: dvcs-autosync is distributed under the terms of the GNU GPL (v2 or v3). The Debian packaging is: Copyright (C) 2011 Rene Mayrhofer and is licensed under the GPL version 3, see "/usr/share/common-licenses/GPL-3". dvcs-autosync-0.5/debian/docs0000644000000000000000000000002611625302736013146 0ustar README TODO CHANGELOG dvcs-autosync-0.5/debian/dvcs-autosync.examples0000644000000000000000000000002211625302736016631 0ustar .autosync-example dvcs-autosync-0.5/debian/pycompat0000644000000000000000000000000211625302736014044 0ustar 2 dvcs-autosync-0.5/debian/rules0000755000000000000000000000022211625302736013351 0ustar #!/usr/bin/make -f DEB_PYTHON_SYSTEM=pysupport include /usr/share/cdbs/1/rules/debhelper.mk include /usr/share/cdbs/1/class/python-distutils.mk dvcs-autosync-0.5/debian/source/0000755000000000000000000000000011625302736013575 5ustar dvcs-autosync-0.5/debian/source/format0000644000000000000000000000001511625302736015004 0ustar 3.0 (native) dvcs-autosync-0.5/dvcs-autosync0000755000000000000000000011644711625302736013620 0ustar #!/usr/bin/python # -*- coding: utf-8 -*- # # ============================================================================ # Copyright René Mayrhofer, 2010-2011 # # Contributors: # * Dieter Plaetinck: documentation and bug fixes, launcher script, config # handling improvements # * René 'Necoro' Neumann: improvements for embedded Jabberbot with regards to # disconnects, bug fixes # * Philipp Tölke: Windows port # * Olivier Guerriat : Mac OS port, Growl support # * evgeni@golov.de: Various bugfixes # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation; either version 2 or 3 of the License. # ============================================================================ from __future__ import with_statement __author__ = 'René Mayrhofer ' __version__ = '0.5' __website__ = 'http://www.mayrhofer.eu.org/dvcs-autosync' __license__ = 'GPL v2 or v3' # Imports for various platforms and error handling concerning optional Python modules import warnings, sys, signal, os, time, subprocess, threading, fnmatch, ConfigParser, logging # OS detection detected_os = False try: import pyinotify detected_os = "LINUX" except: pass try: import win32api detected_os = "WINDOWS" except: pass try: from fsevents import Observer from fsevents import Stream detected_os = "MAC_OS" except: pass if not detected_os: logging.error('Unsupported OS, sorry.') sys.exit(2) if not hasattr(subprocess, 'check_output'): # see https://gist.github.com/839684 def check_output(*popenargs, **kwargs): if 'stdout' in kwargs: raise ValueError('stdout argument not allowed, it will be overridden.') process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs) output, unused_err = process.communicate() retcode = process.poll() if retcode: cmd = kwargs.get("args") if cmd is None: cmd = popenargs[0] raise subprocess.CalledProcessError(retcode, cmd) return output subprocess.check_output = check_output # do not care about deprecation warnings right now, as they are only confusing for users with warnings.catch_warnings(): warnings.filterwarnings("ignore",category=DeprecationWarning) # need to use a private instance of jabberbot for now... # TODO: remove when we no longer need this sys.path.insert(0, '/usr/share/dvcs-autosync') import jabberbot, xmpp botcmd = jabberbot.botcmd # some global variables, will be initialized in main desktopnotifykde = False desktopnotifygnome = False desktopnotifygrowl = False xmppnotify = False knotify = None notifier = None gnotify = None bot = None hostname = None username = None pidfile = None icon = None def printmsg(title, msg, level=logging.INFO): # there are probably more levels but I couldn't find the appropriate docs kdelevels = {logging.DEBUG: 'info', logging.INFO: 'info', logging.WARNING: 'warning', logging.ERROR: 'warning', logging.CRITICAL: 'warning'} try: if desktopnotifygnome: urgencies = {logging.DEBUG: pynotify.URGENCY_LOW, logging.INFO: pynotify.URGENCY_NORMAL, logging.WARNING: pynotify.URGENCY_CRITICAL, logging.ERROR: pynotify.URGENCY_CRITICAL, logging.CRITICAL: pynotify.URGENCY_CRITICAL} n = pynotify.Notification(title, msg) if icon: n.set_icon_from_pixbuf(icon) n.set_urgency(urgencies[level]) n.show() elif desktopnotifykde: knotify.event(kdelevels[level], 'kde', [], title, msg, [], [], 0, dbus_interface="org.kde.KNotify") elif desktopnotifygrowl: gnotify.notify("Every notifications", title, msg, gnotifyIcon) time.sleep(0.1) # When sending multiple notifications at the same time, Growl seems to only consider the latest. This little delay prevent that. if xmppnotify and bot and alsonotify: bot.send(alsonotify, '[%s]: %s' % (title, msg)) except: pass logging.log(level, "NOTIFICATION: %s: %s" % (title, msg)) # this helper class has been shamelessly copied from http://socialwire.ca/2010/01/python-resettable-timer-example/ class ResettableTimer(threading.Thread): """ The ResettableTimer class is a timer whose counting loop can be reset arbitrarily. Its duration is configurable. Commands can be specified for both expiration and update. Its update resolution can also be specified. Resettable timer keeps counting until the "run" method is explicitly killed with the "kill" method. """ def __init__(self, maxtime, expire, inc=None, update=None, arg=None): """ @param maxtime: time in seconds before expiration after resetting in seconds @param expire: function called when timer expires @param inc: amount by which timer increments before updating in seconds, default is maxtime/2 @param update: function called when timer updates @param arg: arbitrary argument that will be passed to function expire when timer expires """ self.maxtime = maxtime self.expire = expire if inc: self.inc = inc else: self.inc = maxtime / 2 if update: self.update = update else: self.update = lambda c : None self.arg = arg self.counter = 0 self.active = True self.stop = False threading.Thread.__init__(self) self.setDaemon(True) def set_counter(self, t): """ Set self.counter to t. @param t: new counter value """ self.counter = t def deactivate(self): """ Set self.active to False. """ self.active = False def kill(self): """ Will stop the counting loop before next update. """ self.stop = True def reset(self): """ Fully rewinds the timer and makes the timer active, such that the expire and update commands will be called when appropriate. """ self.counter = 0 self.active = True def run(self): """ Run the timer loop. """ while True: self.counter = 0 while self.counter < self.maxtime: self.counter += self.inc time.sleep(self.inc) if self.stop: return if self.active: self.update(self.counter) if self.active: self.active = False self.expire(self.arg) class AutosyncJabberBot(jabberbot.JabberBot): def __init__(self, username, password, res=None, debug=False, ignoreownmsg=True): self._running = False self._unsent = [] jabberbot.JabberBot.__init__(self, username, password, res, debug, False, not ignoreownmsg) self.PING_FREQUENCY = 30 def _process_thread(self): self.log.info('Background Jabber bot thread starting') while self._running: try: if self.conn.Process(1) is None: # Process() does not raise IOErrors # instead it returns None if there is no data self.log.warning('Link down') raise IOError self.idle_proc() except IOError: self.conn = None self.log.warning('Received IOError while trying to handle incoming messages, trying to reconnect now') while not self.conn and self._running: time.sleep(10) self.conn = self.connect() # copy self._unsent, s.t. it doesn't gets an infinite loop # this could happen if we try to send a msg, this fails # and then it gets re-appended to self._unsent -- where we try # to send it again ... and again ... and again... unsent = self._unsent self._unsent = [] for msg in unsent: self.send(*msg) def start_serving(self): self.connect() if self.conn: self.log.info('bot connected. serving forever.') else: self.log.warning('could not connect to server - aborting.') return self._running = True self._thread = threading.Thread(target=self._process_thread) self._thread.daemon = True self._thread.start() # this is a hack to get other bots to add this one to their "seen" lists # TODO: still doesn't work, figure out how to use JabberBot to get rid of # 'AutosyncJabberBot : Ignoring message from unseen guest: rene-sync@doc.to/AutosyncJabberBot on iss' self.conn.send(xmpp.Presence(to=username)) def stop_serving(self): self._running = False if self._thread: self._thread.join() def on_ping_timeout(self): raise IOError, "Ping timeout" # override the send method so that connection errors can be handled by trying to reconnect def send(self, user, text, in_reply_to=None, message_type='chat'): try: jabberbot.JabberBot.send(self, user, text, in_reply_to, message_type) except (AttributeError, IOError): if self.conn is not None: # error is something different raise self.log.warning('Received an error while trying to send message. Will send it later.') self._unsent.append((user, text, in_reply_to, message_type)) @botcmd def whoami(self, mess, args): """Tells you your username""" return 'You are %s, I am %s/%s' % (mess.getFrom(), self.jid, self.res) @botcmd def ping(self, mess, args): self.log.debug('Received ping command over Jabber channel') return 'pong' @botcmd def pushed(self, mess, args): self.log.debug('Received pushed command over Jabber channel with args %s from %s' % (args, mess.getFrom())) if mess.getFrom() == str(self.jid) + '/' + self.res: self.log.debug('Ignoring own pushed message looped back by server') else: self.log.debug('Trying to pull from %s' % args) with lock: handler.protected_pull() @botcmd def login(self, mess, args): """The bot sends a "login" message first. ignore it""" return @botcmd def unknown(self, mess, args): """Should somebody say something that is not a command, all bots will reply with "Unknown command...." to which all bots will reply that thay do not know the command "Unknown"...""" return class FileChangeHandler(): def __init__(self, cwd, ignored): self.cwd = cwd self.ignored = ignored # singleton timer for delayed execution of push self._push_timer = None # When set to true, then all events will be ignored. # This is used to temporarily disable file event handling when a local # pull operation is active. self._ignore_events = False # This is a dictionary of all events that occurred within _coalesce_time seconds. # Elements in the sets are tuples of FIFO lists of event types which were delivered # for the respective file path and timers for handling the file, indexed by the # respective file path. self._file_events = dict() def _exec_cmd(self, commands, parms = None): j = 0 for command in commands.split('\n'): cmdarray = command.split(' ') if parms: i = 0 while i < len(cmdarray): if cmdarray[i] == '%s': logging.debug('Substituting cmd part %s with %s', cmdarray[i], parms[j]) cmdarray[i] = parms[j] j=j+1 i=i+1 try: out = subprocess.check_output(cmdarray, cwd=self.cwd, stderr=subprocess.STDOUT) logging.debug("Command '%s' in '%s'. Output:\n%s" % (" ".join (cmdarray), self.cwd, out)) except subprocess.CalledProcessError, e: if hasattr(e, 'output'): printmsg('Command failed', "Command '%s' in '%s' failed. Output:\n%s" % (" ".join (cmdarray), self.cwd, e.output), level=logging.WARNING) else: printmsg('Command failed', "Command '%s' in '%s' failed." % (" ".join (cmdarray), self.cwd), level=logging.WARNING) def _post_action_steps(self, curpath = None): with lock: # the status command should return 0 when nothing has changed retcode = subprocess.call(cmd_status, cwd=self.cwd, shell=True) if retcode != 0: if curpath: commitmsg = 'Autocommit of file %s changed on host %s' % (curpath, hostname) else: commitmsg = 'Autocommit of all changes since last autosync startup on host %s' % hostname self._exec_cmd(cmd_commit, [commitmsg]) if retcode != 0 and syncmethod != 'none': # reset the timer and start in case it is not yet running (start should be idempotent if it already is) # this has the effect that, when another change is committed within the timer period (readfrequency seconds), # then these changes will be pushed in one go if self._push_timer and self._push_timer.is_alive(): logging.debug('Resetting already active push timer to new timeout of %s seconds until push would occur', readfrequency) self._push_timer.reset() else: logging.debug('Starting push timer with %s seconds until push would occur (if no other changes happen in between)', readfrequency) self._push_timer = ResettableTimer(maxtime=readfrequency, expire=self._real_push, inc=1, update=self.timer_tick) self._push_timer.start() else: logging.debug('%s reported that there is nothing to commit, not touching commit timer' % cmd_commit.split(' ')[0]) def _queue_action(self, event, action, parms, act_on_dirs=False): curpath = event.pathname if self._ignore_events: logging.debug('Ignoring event %s to %s, it is most probably caused by a remote change being currently pulled', event.maskname, event.pathname) return if event.dir and not act_on_dirs: logging.debug('Ignoring change to directory %s', curpath) return if any(fnmatch.fnmatch(curpath, pattern) for pattern in self.ignored): logging.debug('Ignoring change to file %s because it matches the ignored patterns from .gitignore', curpath) return # remember the event for this file, but don't act on it immediately # this allows e.g. a file that has just been removed and re-created # immediately afterwards (as many editors do) to be recorded just as # being modified with lock: # each entry in the dict is a tuple of the list of events and a timer if not self._file_events.has_key(curpath): self._file_events[curpath] = [list(), None] # and each entry in the list is a tuple of event name and associated action self._file_events[curpath][0].append((event.maskname, action)) if self._file_events[curpath][1] and self._file_events[curpath][1].is_alive(): logging.debug('Resetting already active coalesce timer to new timeout of %s seconds until coalescing events for file %s would occur', coalesce_seconds, curpath) self._file_events[curpath][1].reset() else: logging.debug('Starting coalesce timer with %s seconds until coalescing events for file %s would occur (if no other changes happen in between)', coalesce_seconds, curpath) self._file_events[curpath][1] = ResettableTimer(maxtime=coalesce_seconds, expire=self._filter_and_handle_actions, inc=1, arg=[curpath, parms]) self._file_events[curpath][1].start() def _filter_and_handle_actions(self, args): curpath = args[0] parms = args[1] logging.info('Coalesce event triggered for file %s', curpath) with lock: logging.debug('Considering file %s, which has the following events recorded:', curpath) events, timer = self._file_events[curpath] lastevent = None lastaction = None for eventtype, action in events: logging.debug(' Event type=%s, action=%s', eventtype, action) if not lastevent: lastevent = eventtype lastaction = action # prio 1: add # prio 2: move # prio 3: modify # prio 4: rm # special case: rm then add --> modify if lastevent == 'IN_DELETE' and eventtype == 'IN_CREATE': lastevent = 'IN_MODIFY' lastaction = cmd_modify break # priority ordering if lastevent == 'IN_MODIFY' and eventtype == 'IN_CREATE': lastevent = eventtype lastaction = action if lastevent == 'IN_DELETE' and eventtype == 'IN_MODIFY': lastevent = eventtype lastaction = action logging.info('Final action for file %s: type=%s, action=%s', curpath, lastevent, lastaction) # and clear again for next events coalescing del self._file_events[curpath] printmsg('Local change', 'Committing changes in %s: %s' % (curpath, lastaction)) self._exec_cmd(lastaction, parms) self._post_action_steps(curpath) def timer_tick(self, counter): logging.debug('Tick %d / %d' % (counter, self._push_timer.maxtime)) def startup(self): with lock: logging.info('Running startup command to check for local changes now: %s', cmd_startup) self._exec_cmd(cmd_startup) self._post_action_steps() def _real_push(self, arg): proc = subprocess.Popen(cmd_remoteurl.split(' '), stdout=subprocess.PIPE, cwd=self.cwd) (remoteurl, errors) = proc.communicate() printmsg('Pushing changes', 'Pushing last local changes to remote repository %s' % remoteurl) with lock: # TODO: check if we actually need a pull or a check-for-pull here # or if all race conditions were already ruled out # if we need a check-for-pull, then something like # git fetch --dry-run | grep "Unpacking objects: # might help #self.protected_pull() self._exec_cmd(cmd_push) # and try to notify other instances if bot: bot.send(username, 'pushed %s' % remoteurl) def protected_pull(self): printmsg('Pulling changes', 'Pulling changes from remote repository') # need to handle file change notification while applying remote # changes caused by the pull: either conservative (ignore all # file notifications while the pull is running) or optimized (replay the # file changes that were seen during the pull after it has finished) if conservative_pull_lock: # conservative strategy: ignore all events from now on self._ignore_events = True with lock: handler._exec_cmd(cmd_pull) if conservative_pull_lock: # pull done, now start handling events again self._ignore_events = False # and handle those local changes that might have happened while the # pull ran and we weren't listening by simply doing the startup # sequence again self.startup() # The definition of this class has to be OS arbitrated because pyinotify can't be # imported under windows and inheriting from pyinotify.ProcessEvent needs it... if detected_os == "LINUX": class LinuxFileChangeHandlerAdapter(pyinotify.ProcessEvent): def my_init(self, handler): self.handler = handler def process_IN_DELETE(self, event): # sanity check - don't remove file if it still exists in the file system! if os.path.exists(event.pathname): logging.debug('Ignoring file delete event on %s, as it still exists - it was probably immediately re-created by the application', event.pathname) return self.handler._queue_action(event, cmd_rm, [event.pathname]) def process_IN_CREATE(self, event): # sanity check - don't add file if it (no longer) exists in the file system! if not os.path.exists(event.pathname): logging.debug('Ignoring file create event on %s, as it (no longer) exists - it was probably created as a temporary file and immediately removed by the application', event.pathname) return self.handler._queue_action(event, cmd_add, [event.pathname]) def process_IN_MODIFY(self, event): self.handler._queue_action(event, cmd_modify, [event.pathname]) def process_IN_CLOSE_WRITE(self, event): self.handler._queue_action(event, cmd_modify, [event.pathname]) def process_IN_ATTRIB(self, event): self.handler._queue_action(event, cmd_modify, [event.pathname]) def process_IN_MOVED_TO(self, event): try: if event.src_pathname: logging.debug('Detected moved file from %s to %s', event.src_pathname, event.pathname) self._handler.queue_action(event, cmd_move, [event.src_pathname, event.pathname], act_on_dirs=True) else: logging.debug('Moved file to %s, but unknown source, will simply add new file', event.pathname) self.handler._queue_action(event, cmd_add, [event.pathname], act_on_dirs=True) except AttributeError: # we don't even have the attribute in the event, so also add logging.debug('Moved file to %s, but unknown source, will simply add new file', event.pathname) self.handler._queue_action(event, cmd_add, [event.pathname], act_on_dirs=True) if detected_os == "WINDOWS": class WindowsFileChangeHandlerAdapter(threading.Thread): def __init__(self, path, ignoreabsolutepaths, handler): threading.Thread.__init__(self) self.handler = handler self.ignoreabsolutepaths = ignoreabsolutepaths self.path = path # This is to mimic the event-type of inotify class MyEvent(): def __init__(self, dir, pathname, action): self.dir = dir self.pathname = pathname self.maskname = [ "", "IN_CREATE", "IN_DELETE", "IN_MODIFY", "IN_DELETE", "IN_CREATE"][action] def run(self): import win32file, win32con FILE_LIST_DIRECTORY = 0x0001 path_to_watch = self.path hDir = win32file.CreateFile ( path_to_watch, FILE_LIST_DIRECTORY, win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE, None, win32con.OPEN_EXISTING, win32con.FILE_FLAG_BACKUP_SEMANTICS, None ) while 1: results = win32file.ReadDirectoryChangesW ( hDir, 1024, True, win32con.FILE_NOTIFY_CHANGE_FILE_NAME | win32con.FILE_NOTIFY_CHANGE_DIR_NAME | win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES | win32con.FILE_NOTIFY_CHANGE_SIZE | win32con.FILE_NOTIFY_CHANGE_LAST_WRITE | win32con.FILE_NOTIFY_CHANGE_SECURITY, None, None ) for action, file in results: full_filename = os.path.join (path_to_watch, file) #check if this file is ignored: if True in [x in full_filename for x in self.ignoreabsolutepaths]: continue event = self.MyEvent(os.path.isdir(file), file, action) if action == 1 or action == 5: #CREATE or MOVE_TO self.handler._queue_action(event, cmd_add, [event.pathname]) elif action == 2 or action == 4: #DELETE or MOVE_FROM if os.path.exists(event.pathname): logging.debug('Ignoring file delete event on %s, as it still exists - it was probably immediately re-created by the application', event.pathname) continue self.handler._queue_action(event, cmd_rm, [event.pathname]) elif action == 3: #MODIFY: self.handler._queue_action(event, cmd_modify, [event.pathname]) if detected_os == "MAC_OS": class MacOSFileChangeHandlerAdapter(threading.Thread): def __init__(self, path, ignoreabsolutepaths, handler): threading.Thread.__init__(self) self.handler = handler self.ignoreabsolutepaths = ignoreabsolutepaths self.path = path # This is to mimic the event-type of inotify class MyEvent(): def __init__(self, dir, pathname, action): self.dir = dir self.pathname = pathname masks = { # from doc : http://developer.apple.com/library/mac/#documentation/Darwin/Reference/FSEvents_Ref/FSEvents_h/index.html#HeaderDoc_enums 256:"IN_CREATE", # created 512:"IN_DELETE", # removed # in doc, but don't seem to be used, included to prevent potential bug 2048:"IN_MODIFY", # renamed 4096:"IN_MODIFY", # modified 0x00000400:'InodeMetaMod', 0x00002000:'FinderInfoMod', 0x00004000:'ChangeOwner', 0x00008000:'XattrMod', # not in doc, but actually used 64:"IN_DELETE", # before rename 128:"IN_CREATE", # after rename 2:"IN_MODIFY", } self.maskname = masks[action] print self.maskname def __call__(self, event): for ignoreabsolutepath in self.ignoreabsolutepaths: if event.name.startswith(ignoreabsolutepath): return event = self.MyEvent(os.path.isdir(event.name), event.name, event.mask) if event.maskname == "IN_CREATE": #CREATE or MOVE_TO self.handler._queue_action(event, cmd_add, [event.pathname], act_on_dirs=True) elif event.maskname == "IN_DELETE": #DELETE or MOVE_FROM if os.path.exists(event.pathname): logging.debug('Ignoring file delete event on %s, as it still exists - it was probably immediately re-created by the application', event.pathname) return self.handler._queue_action(event, cmd_rm, [event.pathname], act_on_dirs=True) elif event.maskname == "IN_MODIFY": #MODIFY: self.handler._queue_action(event, cmd_modify, [event.pathname], act_on_dirs=True) def run(self): observer = Observer() observer.start() #handler = self.process_event(self) stream = Stream(self, self.path, file_events=True) observer.schedule(stream) def initialize_win32notify(path, ignoreabsolutepaths, handler): # Windows adapter = WindowsFileChangeHandlerAdapter(path, ignoreabsolutepaths, handler) adapter.daemon = True adapter.start() def initialize_fsevents(path, ignoreabsolutepaths, handler): # Mac OS adapter = MacOSFileChangeHandlerAdapter(path, ignoreabsolutepaths, handler) adapter.daemon = True adapter.start() def initialize_inotify(ignoreabsolutepaths, path, ignorefilepatterns, readfrequency, handler): # Linux excl = pyinotify.ExcludeFilter(ignoreabsolutepaths) wm = pyinotify.WatchManager() # TODO: frequency doesn't work.... notifier = pyinotify.ThreadedNotifier(wm, LinuxFileChangeHandlerAdapter(handler = handler), read_freq=readfrequency) #notifier = pyinotify.ThreadedNotifier(wm, handler) # coalescing events needs pyinotify >= 0.9, so make this optional try: notifier.coalesce_events() except AttributeError as e: logging.warning('Cannot coalesce events, pyinotify does not seem to support it (maybe too old): %s', e) mask = pyinotify.IN_DELETE | pyinotify.IN_CREATE | pyinotify.IN_CLOSE_WRITE | pyinotify.IN_ATTRIB | pyinotify.IN_MOVED_FROM | pyinotify.IN_MOVED_TO | pyinotify.IN_DONT_FOLLOW | pyinotify.IN_ONLYDIR try: logging.debug('Adding recursive, auto-adding watch for path %s with event mask %d', path, mask) wd = wm.add_watch(path, mask, rec=True, auto_add=True, quiet=False, exclude_filter=excl) if wd <= 0: logging.warning('Unable to add watch for path %s - this will not work', path) except pyinotify.WatchManagerError, e: logging.warning("pyinotify.WatchManagerError: %s, %s", e, e.wmd) logging.info('Start monitoring %s (type c^c to exit)', path) notifier.start() def config_get (section, option, optional=False): ret = None try: ret = config.get(section, option) except ConfigParser.NoSectionError: if not optional: printmsg ("Configuration error", "Could not load section %s from configuration at %s" % (section, config_locations), level=logging.ERROR) sys.exit(2) except ConfigParser.NoOptionError: if not optional: printmsg ("Configuration error", "Could not load option %s from section %s from configuration at %s" % (option, section, config_locations), level=logging.ERROR) sys.exit(2) except ConfigParser.ParsingError: printmsg ("Configuration error", "Could not parse configuration at %s" % config_locations, level=logging.ERROR) sys.exit(2) return ret def signal_handler(signal, frame): logging.info('You pressed Ctrl+C, exiting gracefully!') if notifier: notifier.stop() if bot: bot.stop_serving() # also remove the pidfile after a clean shutdown if pidfile and os.path.exists(pidfile): os.remove(pidfile) sys.exit(0) if __name__ == '__main__': logging.basicConfig(level=logging.DEBUG) # try to set up desktop notification, first for KDE4, then for Gnome # the signature is not correct, so rely on pynotify only at the moment #try: #import dbus #knotify = dbus.SessionBus().get_object("org.kde.knotify", "/Notify") #knotify.event("warning", "autosync application", [], #'KDE4 notification initialized', 'Initialized KDE4 desktop notification via DBUS', #[], [], 0, dbus_interface='org.kde.KNotify') #desktopnotifykde = True #except: #print 'KDE4 KNotify does not seem to run or dbus is not installed' try: import pynotify, gtk try: icon = gtk.IconTheme().load_icon('dvcs-autosync', 48, gtk.ICON_LOOKUP_GENERIC_FALLBACK) except: icon = None if pynotify.init('autosync application'): logging.info('pynotify initialized successfully, will use desktop notifications') desktopnotifygnome = True else: logging.warning('there was a problem initializing the pynotify module') except: logging.info('pynotify does not seem to be installed') try: import Growl gnotifyImagePath = os.path.abspath('/usr/share/icons/hicolor/48x48/apps/dvcs-autosync.png') if os.path.exists(gnotifyImagePath): gnotifyIcon = Growl.Image.imageFromPath(gnotifyImagePath) else: gnotifyIcon = None gnotify = Growl.GrowlNotifier( "AutoSync", ["Every notifications"], applicationIcon=gnotifyIcon) gnotify.register() logging.info('Growl initialized successfully, will use desktop notifications') desktopnotifygrowl = True except: logging.info('Growl does not seem to be installed') config = ConfigParser.RawConfigParser() defaultcfgpath = os.path.expanduser('~/.autosync') if len(sys.argv) >= 2: config_locations = [sys.argv[1], defaultcfgpath] else: config_locations = [defaultcfgpath] read_configfiles = config.read(config_locations) if len(read_configfiles) == 0: logging.error('No config file specified or config file(s) %s could not be opened' % config_locations) sys.exit(10) pathstr = config_get('autosync', 'path') path = os.path.normpath(os.path.expanduser(pathstr)) if os.path.isdir(path): logging.info('Watching path %s', path) else: logging.error('path %s (expanded from %s) does not exist', path, pathstr) sys.exit(100) # ensure that the script is not running twice with the same config file pidfile = config_get('autosync', 'pidfile', optional=True) if not pidfile: # default pidfile name if not specified in config pidfile = read_configfiles[0] + '.pid' pidfile = os.path.normpath(os.path.expanduser(pidfile)) logging.debug('Checking/writing pidfile %s' % pidfile) # does the file already exist? if os.access(pidfile, os.F_OK): # check if a process with that PID is still running pidfd = open(pidfile) pidfd.seek(0) old_pid = pidfd.readline() # Now we check the PID from lock file matches to the current # process PID if os.path.exists("/proc/%s" % old_pid): logging.error('DVCS-autosync already running with config file %s under PID %s, exiting now' % (read_configfiles[0], old_pid)) sys.exit(9) else: logging.warning('PID file %s already exists, but no process seems to be running, removing file now' % pidfile) os.remove(pidfile) # if we get to here, process is not running and pidfile doesn't exist (anymore) cur_pid = str(os.getpid()) pidfd = open(pidfile, 'w') pidfd.write(cur_pid) pidfd.close() ignorepaths = config_get('autosync', 'ignorepath') readfrequency = int(config_get('autosync', 'readfrequency')) coalesce_seconds = 2 syncmethod = config_get('autosync', 'syncmethod') # in the upper pynotify try, the desktopnotify options are set, but can override here notifymethod = config_get('autosync', 'notifymethod', optional=True) if not notifymethod or notifymethod == 'desktop': xmppnotify = False logging.info('Using only desktop notification') elif notifymethod == 'xmpp': xmppnotify = True desktopnotifygnome = False desktopnotifykde = False desktopnotifygrowl = False logging.info('Using only XMPP notification') elif notifymethod == 'all': xmppnotify = True logging.info('Using all notification methods') elif notifymethod == 'none': xmppnotify = False desktopnotifygnome = False desktopnotifykde = False desktopnotifygrowl = False logging.info('Disabling all notification methods, will only log to console') else: logging.warning('Unknown notifymethod "%s" configured, will keep default (desktop)', notifymethod) pulllock = config_get('autosync', 'pulllock') if pulllock == 'conservative': conservative_pull_lock = True elif pulllock == 'optimized': conservative_pull_lock = False logging.error('Optimized pull strategy not fully implemented yet (event replay queue missing)') sys.exit(101) else: logging.error('Unknown pull lock strategy %s, please use either conservative or optimized', pulllock) sys.exit(100) # Read required DVCS commands cmd_status = config_get('dvcs', 'statuscmd') cmd_startup = config_get('dvcs', 'startupcmd') cmd_commit = config_get('dvcs', 'commitcmd') cmd_push = config_get('dvcs', 'pushcmd') cmd_pull = config_get('dvcs', 'pullcmd') cmd_add = config_get('dvcs', 'addcmd') cmd_rm = config_get('dvcs', 'rmcmd') cmd_modify = config_get('dvcs', 'modifycmd') cmd_move = config_get('dvcs', 'movecmd') cmd_remoteurl = config_get('dvcs', 'remoteurlcmd') # TODO: this is currently git-specific, should be configurable ignorefile = os.path.join(path, '.gitignore') # load the patterns and match them internally with fnmatch if os.path.exists(ignorefile): f = open(ignorefile, 'r') ignorefilepatterns = [pat.strip() for pat in f.readlines()] f.close() else: ignorefilepatterns = [] # (unfortunately, can't use pyinotify.ExcludeFilter, because this expects regexes (which .gitignore doesn't support)) logging.info('Ignoring files matching any of the patterns %s', ' '.join(ignorefilepatterns)) # but we can use the ignore filter with our own pathname excludes # However, need to prepend the watch path name, as the excludes need to be # absolute path names. ignoreabsolutepaths = [os.path.normpath(path + os.sep + ignorepath) for ignorepath in ignorepaths.split()] logging.info('Adding list to inotify exclude filter: %s', ignoreabsolutepaths) signal.signal(signal.SIGINT, signal_handler) if syncmethod == 'xmpp': username = config_get('xmpp', 'username') password = config_get('xmpp', 'password') alsonotify = config_get('xmpp', 'alsonotify', optional=True) if xmppnotify and not alsonotify: logger.warning('XMPP notification requested, but alsonotify option not configured, will not send XMPP notifications') if (detected_os == "LINUX") or (detected_os == "MAC_OS"): hostname = os.uname()[1] elif detected_os == "WINDOWS": hostname = win32api.GetComputerName() else: hostname = "UNSUPPORTED_OS" res = 'AutosyncJabberBot on %s' % hostname try: with warnings.catch_warnings(): warnings.filterwarnings("ignore",category=DeprecationWarning) bot = AutosyncJabberBot(username, password, res=res, debug=False, ignoreownmsg=False) bot.start_serving() bot.send(username, 'login %s' % res) printmsg('Autosync Jabber login successful', 'Successfully logged into account %s' % username) except Exception as e: logging.error("Exception %s: %s", type(e), e) printmsg('Autosync Jabber login failed', 'Could not login to Jabber account %s. Will not announce pushes to other running autosync instances.' % username) elif syncmethod == 'autosync-server': logging.error('Alternative autosync-server sync method not fully implemented yet') sys.exit(101) elif syncmethod == 'none': logging.info('Synchronization method none configured, will not attempt to synchronize with any repository') else: printmsg('No synchronization method configured', 'No or unknown syncmethod configured, will not attempt to synchronize with any repository', level=logging.WARNING) printmsg('autosync starting', 'Initialization of local file notifications and Jabber login done, starting main loop') handler = FileChangeHandler(cwd=path, ignored=ignorefilepatterns) # this is a central lock for guarding repository operations lock = threading.RLock() if detected_os == "LINUX": initialize_inotify(ignoreabsolutepaths, path, ignorefilepatterns, readfrequency, handler) elif detected_os == "WINDOWS": initialize_win32notify(path, ignoreabsolutepaths, handler) elif detected_os == "MAC_OS": initialize_fsevents(path, ignoreabsolutepaths, handler) else: pass #TODO logging.info('Executing startup synchronizaion') if syncmethod != 'none': handler.protected_pull() if not conservative_pull_lock or syncmethod == 'none': # only need to run the startup command here when not using conservative pull locking - otherwise the protected_pull will already do it handler.startup() logging.info('----------------------------------------------------------------') while True: time.sleep(10) dvcs-autosync-0.5/dvcs-autosync.desktop0000644000000000000000000000060111625302736015245 0ustar [Desktop Entry] Name=DVCS-Autosync GenericName=File Synchronizer based on Distributed Version Control Comment=Synchronize and version your files across multiple computers with distributed version control (by default with Git) Exec=/usr/share/dvcs-autosync/autosync-xdg-launcher.sh Terminal=false Type=Application Icon=dvcs-autosync Categories=Network;FileTransfer; StartupNotify=false dvcs-autosync-0.5/growl-python/0000755000000000000000000000000011625302736013524 5ustar dvcs-autosync-0.5/growl-python/Growl.py0000644000000000000000000001643611625302736015202 0ustar """ A Python module that enables posting notifications to the Growl daemon. See for more information. """ __version__ = "0.7" __author__ = "Mark Rowe " __copyright__ = "(C) 2003 Mark Rowe . Released under the BSD license." __contributors__ = ["Ingmar J Stein (Growl Team)", "Rui Carmo (http://the.taoofmac.com)", "Jeremy Rossi ", "Peter Hosey (Growl Team)", ] import _growl import types import struct import hashlib import socket GROWL_UDP_PORT=9887 GROWL_PROTOCOL_VERSION=1 GROWL_TYPE_REGISTRATION=0 GROWL_TYPE_NOTIFICATION=1 GROWL_APP_NAME="ApplicationName" GROWL_APP_ICON="ApplicationIcon" GROWL_NOTIFICATIONS_DEFAULT="DefaultNotifications" GROWL_NOTIFICATIONS_ALL="AllNotifications" GROWL_NOTIFICATIONS_USER_SET="AllowedUserNotifications" GROWL_NOTIFICATION_NAME="NotificationName" GROWL_NOTIFICATION_TITLE="NotificationTitle" GROWL_NOTIFICATION_DESCRIPTION="NotificationDescription" GROWL_NOTIFICATION_ICON="NotificationIcon" GROWL_NOTIFICATION_APP_ICON="NotificationAppIcon" GROWL_NOTIFICATION_PRIORITY="NotificationPriority" GROWL_NOTIFICATION_STICKY="NotificationSticky" GROWL_APP_REGISTRATION="GrowlApplicationRegistrationNotification" GROWL_APP_REGISTRATION_CONF="GrowlApplicationRegistrationConfirmationNotification" GROWL_NOTIFICATION="GrowlNotification" GROWL_SHUTDOWN="GrowlShutdown" GROWL_PING="Honey, Mind Taking Out The Trash" GROWL_PONG="What Do You Want From Me, Woman" GROWL_IS_READY="Lend Me Some Sugar; I Am Your Neighbor!" growlPriority = {"Very Low":-2,"Moderate":-1,"Normal":0,"High":1,"Emergency":2} class netgrowl: """Builds a Growl Network Registration packet. Defaults to emulating the command-line growlnotify utility.""" __notAllowed__ = [GROWL_APP_ICON, GROWL_NOTIFICATION_ICON, GROWL_NOTIFICATION_APP_ICON] def __init__(self, hostname, password ): self.hostname = hostname self.password = password self.socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) def send(self, data): self.socket.sendto(data, (self.hostname, GROWL_UDP_PORT)) def PostNotification(self, userInfo): if userInfo.has_key(GROWL_NOTIFICATION_PRIORITY): priority = userInfo[GROWL_NOTIFICATION_PRIORITY] else: priority = 0 if userInfo.has_key(GROWL_NOTIFICATION_STICKY): sticky = userInfo[GROWL_NOTIFICATION_STICKY] else: sticky = False data = self.encodeNotify(userInfo[GROWL_APP_NAME], userInfo[GROWL_NOTIFICATION_NAME], userInfo[GROWL_NOTIFICATION_TITLE], userInfo[GROWL_NOTIFICATION_DESCRIPTION], priority, sticky) return self.send(data) def PostRegistration(self, userInfo): data = self.encodeRegistration(userInfo[GROWL_APP_NAME], userInfo[GROWL_NOTIFICATIONS_ALL], userInfo[GROWL_NOTIFICATIONS_DEFAULT]) return self.send(data) def encodeRegistration(self, application, notifications, defaultNotifications): data = struct.pack("!BBH", GROWL_PROTOCOL_VERSION, GROWL_TYPE_REGISTRATION, len(application) ) data += struct.pack("BB", len(notifications), len(defaultNotifications) ) data += application for i in notifications: encoded = i.encode("utf-8") data += struct.pack("!H", len(encoded)) data += encoded for i in defaultNotifications: data += struct.pack("B", i) return self.encodePassword(data) def encodeNotify(self, application, notification, title, description, priority = 0, sticky = False): application = application.encode("utf-8") notification = notification.encode("utf-8") title = title.encode("utf-8") description = description.encode("utf-8") flags = (priority & 0x07) * 2 if priority < 0: flags |= 0x08 if sticky: flags = flags | 0x0001 data = struct.pack("!BBHHHHH", GROWL_PROTOCOL_VERSION, GROWL_TYPE_NOTIFICATION, flags, len(notification), len(title), len(description), len(application) ) data += notification data += title data += description data += application return self.encodePassword(data) def encodePassword(self, data): checksum = hashlib.md5() checksum.update(data) if self.password: checksum.update(self.password) data += checksum.digest() return data class _ImageHook(type): def __getattribute__(self, attr): global Image if Image is self: from _growlImage import Image return getattr(Image, attr) class Image(object): __metaclass__ = _ImageHook class _RawImage(object): def __init__(self, data): self.rawImageData = data class GrowlNotifier(object): """ A class that abstracts the process of registering and posting notifications to the Growl daemon. You can either pass `applicationName', `notifications', `defaultNotifications' and `applicationIcon' to the constructor or you may define them as class-level variables in a sub-class. `defaultNotifications' is optional, and defaults to the value of `notifications'. `applicationIcon' is also optional but defaults to a pointless icon so is better to be specified. """ applicationName = 'GrowlNotifier' notifications = [] defaultNotifications = [] applicationIcon = None _notifyMethod = _growl def __init__(self, applicationName=None, notifications=None, defaultNotifications=None, applicationIcon=None, hostname=None, password=None): if applicationName: self.applicationName = applicationName assert self.applicationName, 'An application name is required.' if notifications: self.notifications = list(notifications) assert self.notifications, 'A sequence of one or more notification names is required.' if defaultNotifications is not None: self.defaultNotifications = list(defaultNotifications) elif not self.defaultNotifications: self.defaultNotifications = list(self.notifications) if applicationIcon is not None: self.applicationIcon = self._checkIcon(applicationIcon) elif self.applicationIcon is not None: self.applicationIcon = self._checkIcon(self.applicationIcon) if hostname is not None and password is not None: self._notifyMethod = netgrowl(hostname, password) elif hostname is not None or password is not None: raise KeyError, "Hostname and Password are both required for a network notification" def _checkIcon(self, data): if isinstance(data, str): return _RawImage(data) else: return data def register(self): if self.applicationIcon is not None: self.applicationIcon = self._checkIcon(self.applicationIcon) regInfo = {GROWL_APP_NAME: self.applicationName, GROWL_NOTIFICATIONS_ALL: self.notifications, GROWL_NOTIFICATIONS_DEFAULT: self.defaultNotifications, GROWL_APP_ICON:self.applicationIcon, } self._notifyMethod.PostRegistration(regInfo) def notify(self, noteType, title, description, icon=None, sticky=False, priority=None): assert noteType in self.notifications notifyInfo = {GROWL_NOTIFICATION_NAME: noteType, GROWL_APP_NAME: self.applicationName, GROWL_NOTIFICATION_TITLE: title, GROWL_NOTIFICATION_DESCRIPTION: description, } if sticky: notifyInfo[GROWL_NOTIFICATION_STICKY] = 1 if priority is not None: notifyInfo[GROWL_NOTIFICATION_PRIORITY] = priority if icon: notifyInfo[GROWL_NOTIFICATION_ICON] = self._checkIcon(icon) self._notifyMethod.PostNotification(notifyInfo) dvcs-autosync-0.5/growl-python/growlImage.m0000644000000000000000000002025011625302736015776 0ustar /* * Copyright 2004 Mark Rowe * Released under the BSD license. */ #include "Python.h" #import typedef struct { PyObject_HEAD NSImage *theImage; } ImageObject; static PyTypeObject ImageObject_Type; #define ImageObject_Check(v) ((v)->ob_type == &ImageObject_Type) static ImageObject * newImageObject(NSImage *img) { ImageObject *self; if (! img) { PyErr_SetString(PyExc_TypeError, "Invalid image."); return NULL; } self = PyObject_New(ImageObject, &ImageObject_Type); if (! self) return NULL; self->theImage = [img retain]; return self; } static void ImageObject_dealloc(ImageObject *self) { PyObject_Del(self); } static PyObject * ImageObject_getAttr(PyObject *self, PyObject *attr) { char *theAttr = PyString_AsString(attr); NSAutoreleasePool *pool = nil; if (strcmp(theAttr, "rawImageData") == 0) { pool = [[NSAutoreleasePool alloc] init]; NSData *imageData = [((ImageObject *) self)->theImage TIFFRepresentation]; PyObject *pyImageData = PyString_FromStringAndSize([imageData bytes], [imageData length]); [pool release]; return pyImageData; } else return PyObject_GenericGetAttr(self, attr); } static PyObject * ImageObject_imageFromPath(PyTypeObject *cls, PyObject *args) { ImageObject *self; char *fileName_ = NULL; NSString *fileName = nil; NSImage *theImage = nil; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, "et:imageFromPath", Py_FileSystemDefaultEncoding, &fileName_)) return NULL; pool = [[NSAutoreleasePool alloc] init]; fileName = [NSString stringWithUTF8String:fileName_]; theImage = [[[NSImage alloc] initWithContentsOfFile:fileName] autorelease]; self = newImageObject(theImage); [pool release]; return (PyObject *) self; } static PyObject * ImageObject_imageWithData(PyTypeObject *cls, PyObject *args) { ImageObject *self; char *imageData = NULL; int imageDataSize = 0; NSImage *theImage = nil; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, "s#:imageWithData", &imageData, &imageDataSize)) return NULL; pool = [[NSAutoreleasePool alloc] init]; theImage = [[[NSImage alloc] initWithData:[NSData dataWithBytes:imageData length:imageDataSize]] autorelease]; self = newImageObject(theImage); [pool release]; return (PyObject *) self; } static PyObject * ImageObject_imageWithIconForFile(PyTypeObject *cls, PyObject *args) { ImageObject *self; char *fileName_ = NULL; NSString *fileName = nil; NSImage *theImage = nil; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, "et:imageWithIconForFile", Py_FileSystemDefaultEncoding, &fileName_)) return NULL; pool = [[NSAutoreleasePool alloc] init]; fileName = [NSString stringWithUTF8String:fileName_]; theImage = [[NSWorkspace sharedWorkspace] iconForFile:fileName]; self = newImageObject(theImage); [pool release]; return (PyObject *) self; } static PyObject * ImageObject_imageWithIconForFileType(PyTypeObject *cls, PyObject *args) { ImageObject *self; char *fileType = NULL; NSImage *theImage = nil; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, "s:imageWithIconForFileType", &fileType)) return NULL; pool = [[NSAutoreleasePool alloc] init]; theImage = [[NSWorkspace sharedWorkspace] iconForFileType:[NSString stringWithUTF8String:fileType]]; self = newImageObject(theImage); [pool release]; return (PyObject *) self; } static PyObject * ImageObject_imageWithIconForCurrentApplication(PyTypeObject *cls, PyObject *args) { ImageObject *self; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, ":imageWithIconForCurrentApplication")) return NULL; pool = [[NSAutoreleasePool alloc] init]; self = newImageObject([NSApp applicationIconImage]); [pool release]; return (PyObject *) self; } static PyObject * ImageObject_imageWithIconForApplication(PyTypeObject *cls, PyObject *args) { ImageObject *self; char *appName_ = NULL; NSString *appName = nil; NSString *appPath = nil; NSImage *theImage = nil; NSAutoreleasePool *pool = nil; if (! PyArg_ParseTuple(args, "et:imageWithIconForApplication", Py_FileSystemDefaultEncoding, &appName_)) return NULL; pool = [[NSAutoreleasePool alloc] init]; appName = [NSString stringWithUTF8String:appName_]; appPath = [[NSWorkspace sharedWorkspace] fullPathForApplication:appName]; if (! appPath) { PyErr_Format(PyExc_RuntimeError, "Application named '%s' not found", appName_); self = NULL; goto done; } theImage = [[NSWorkspace sharedWorkspace] iconForFile:appPath]; self = newImageObject(theImage); done: [pool release]; return (PyObject *) self; } static PyMethodDef ImageObject_methods[] = { {"imageFromPath", (PyCFunction)ImageObject_imageFromPath, METH_VARARGS | METH_CLASS}, {"imageWithData", (PyCFunction)ImageObject_imageWithData, METH_VARARGS | METH_CLASS}, {"imageWithIconForFile", (PyCFunction)ImageObject_imageWithIconForFile, METH_VARARGS | METH_CLASS}, {"imageWithIconForFileType", (PyCFunction)ImageObject_imageWithIconForFileType, METH_VARARGS | METH_CLASS}, {"imageWithIconForCurrentApplication", (PyCFunction)ImageObject_imageWithIconForCurrentApplication, METH_VARARGS | METH_CLASS}, {"imageWithIconForApplication", (PyCFunction)ImageObject_imageWithIconForApplication, METH_VARARGS | METH_CLASS}, {NULL, NULL} /* sentinel */ }; static PyTypeObject ImageObject_Type = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "_growlImage.Image", /*tp_name*/ sizeof(ImageObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)ImageObject_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ ImageObject_getAttr, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_CLASS, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ ImageObject_methods, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ PyType_GenericAlloc, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ }; static PyMethodDef _growlImage_methods[] = { {NULL, NULL} }; PyMODINIT_FUNC init_growlImage(void) { PyObject *m; if (PyType_Ready(&ImageObject_Type) < 0) return; m = Py_InitModule("_growlImage", _growlImage_methods); PyModule_AddObject(m, "Image", (PyObject *)&ImageObject_Type); } dvcs-autosync-0.5/growl-python/libgrowl.c0000644000000000000000000001346711625302736015524 0ustar /* * Copyright 2004-2005 The Growl Project. * Created by Jeremy Rossi * Released under the BSD license. */ #include #include static PyObject * growl_PostDictionary(CFStringRef name, PyObject *self, PyObject *args) { int i, j; PyObject *inputDict; PyObject *pKeys = NULL; PyObject *pKey, *pValue; CFMutableDictionaryRef note = CFDictionaryCreateMutable(kCFAllocatorDefault, /*capacity*/ 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &inputDict)) goto error; pKeys = PyDict_Keys(inputDict); for (i = 0; i < PyList_Size(pKeys); ++i) { CFStringRef convertedKey; /* Converting the PyDict key to NSString and used for key in note */ pKey = PyList_GetItem(pKeys, i); if (!pKey) // Exception already set goto error; pValue = PyDict_GetItem(inputDict, pKey); if (!pValue) { // XXX Neeed a real Error message here. PyErr_SetString(PyExc_TypeError," "); goto error; } if (PyUnicode_Check(pKey)) { convertedKey = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(pKey), PyUnicode_GET_DATA_SIZE(pKey), kCFStringEncodingUnicode, false); } else if (PyString_Check(pKey)) { convertedKey = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AsString(pKey), kCFStringEncodingUTF8); } else { PyErr_SetString(PyExc_TypeError,"The Dict keys must be strings/unicode"); goto error; } /* Converting the PyDict value to NSString or NSData based on class */ if (PyString_Check(pValue)) { CFStringRef convertedValue = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AS_STRING(pValue), kCFStringEncodingUTF8); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyUnicode_Check(pValue)) { CFStringRef convertedValue = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(pValue), PyUnicode_GET_DATA_SIZE(pValue), kCFStringEncodingUnicode, false); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyInt_Check(pValue)) { long v = PyInt_AS_LONG(pValue); CFNumberRef convertedValue = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongType, &v); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (pValue == Py_None) { CFDataRef convertedValue = CFDataCreate(kCFAllocatorDefault, NULL, 0); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyList_Check(pValue)) { int size = PyList_Size(pValue); CFMutableArrayRef listHolder = CFArrayCreateMutable(kCFAllocatorDefault, size, &kCFTypeArrayCallBacks); for (j = 0; j < size; ++j) { PyObject *lValue = PyList_GetItem(pValue, j); if (PyString_Check(lValue)) { CFStringRef convertedValue = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AS_STRING(lValue), kCFStringEncodingUTF8); CFArrayAppendValue(listHolder, convertedValue); CFRelease(convertedValue); } else if (PyUnicode_Check(lValue)) { CFStringRef convertedValue = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(lValue), PyUnicode_GET_DATA_SIZE(lValue), kCFStringEncodingUnicode, false); CFArrayAppendValue(listHolder, convertedValue); CFRelease(convertedValue); } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError,"The lists must only contain strings"); goto error; } } CFDictionarySetValue(note, convertedKey, listHolder); CFRelease(listHolder); } else if (PyObject_HasAttrString(pValue, "rawImageData")) { PyObject *lValue = PyObject_GetAttrString(pValue, "rawImageData"); if (!lValue) { goto error; } else if (PyString_Check(lValue)) { CFDataRef convertedValue = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)PyString_AsString(lValue), PyString_Size(lValue)); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError, "Icon with rawImageData attribute present must ensure it is a string."); goto error; } } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError, "Value is not of Str/List"); goto error; } CFRelease(convertedKey); } Py_BEGIN_ALLOW_THREADS CFNotificationCenterPostNotification(CFNotificationCenterGetDistributedCenter(), /*name*/ name, /*object*/ NULL, /*userInfo*/ note, /*deliverImmediately*/ false); CFRelease(note); Py_END_ALLOW_THREADS Py_DECREF(pKeys); Py_INCREF(Py_None); return Py_None; error: CFRelease(note); Py_XDECREF(pKeys); return NULL; } static PyObject * growl_PostRegistration(PyObject *self, PyObject *args) { return growl_PostDictionary(CFSTR("GrowlApplicationRegistrationNotification"), self, args); } static PyObject * growl_PostNotification(PyObject *self, PyObject *args) { return growl_PostDictionary(CFSTR("GrowlNotification"), self, args); } static PyMethodDef GrowlMethods[] = { {"PostNotification", growl_PostNotification, METH_VARARGS, "Send a notification to GrowlHelperApp"}, {"PostRegistration", growl_PostRegistration, METH_VARARGS, "Send a registration to GrowlHelperApp"}, {NULL, NULL, 0, NULL} /* Sentinel */ }; PyMODINIT_FUNC init_growl(void) { Py_InitModule("_growl", GrowlMethods); } dvcs-autosync-0.5/growl-python/setup.py0000644000000000000000000000140311625302736015234 0ustar #!/usr/bin/python from distutils.core import setup, Extension import sys _growl = Extension('_growl', extra_link_args = ["-framework","CoreFoundation"], sources = ['libgrowl.c']) _growlImage = Extension('_growlImage', extra_link_args = ["-framework","Cocoa"], sources = ['growlImage.m']) if sys.platform.startswith("darwin"): modules = [_growl, _growlImage] else: modules = [] setup(name="py-Growl", version="0.0.7", description="Python bindings for posting notifications to the Growl daemon", author="Mark Rowe", author_email="bdash@users.sourceforge.net", url="http://growl.info", py_modules=["Growl"], ext_modules = modules ) dvcs-autosync-0.5/icons/0000755000000000000000000000000011625302736012166 5ustar dvcs-autosync-0.5/icons/16x16/0000755000000000000000000000000011625302736012753 5ustar dvcs-autosync-0.5/icons/16x16/dvcs-autosync.png0000644000000000000000000000113711625302736016265 0ustar PNG  IHDRa&IDATxڕnPr̜936Nk /zF&D:@*G2C<E,A4F$B8D0,##R@pB>q)>Ysil6t:eL&Fzt:hhZ ܏.p"AF w7aETBрVp>8ѽfɔL%p}7 -f3=ߠ\.DprBQx`X,^l0N t Xp1UR"C;KZuV[#L&8 x@BۥBQ%TT[`0s p8`ݲBff^gw@PC`Sk;Rd{`-#: x1(uqKF1!sAU}xrHB)qV+=0AIJ7zH=lfTHHE-.u*ҥRPKD>fs"ӏIENDB`dvcs-autosync-0.5/icons/22x22/0000755000000000000000000000000011625302736012745 5ustar dvcs-autosync-0.5/icons/22x22/dvcs-autosync.png0000644000000000000000000000163611625302736016263 0ustar PNG  IHDRj PLTExxxÿ›óЈ½ýľľſſztRNS $eeeenXYcvIDATx]_`حXXݢ81Q 3?y&2)seiqanfjb|ltx?=!a .DnΠ 'u0o2WP8nsP_Q` `<f^A᝷5r#Ų,>rV.zStlGCeH+(G}6B(^~~=~*S60CiB9芪C: $99HN2!%rLlܿbc#| 6mIENDB`dvcs-autosync-0.5/icons/32x32/0000755000000000000000000000000011625302736012747 5ustar dvcs-autosync-0.5/icons/32x32/dvcs-autosync.png0000644000000000000000000000247011625302736016262 0ustar PNG  IHDR DOPLTESSS000ȟǝ䈊¼½þĿſ$tRNS $%@2tIDATxڭWWA@+V h b76"D"vi6콗Hbj kL6fΚd72̽3췣/Wrn[]m׮^z2u՗V d,;+FH$ހQff$ :!GzBdt Q<.X}H/CG%Zy~j+8qfj\7Y?W?zTj.bߌjqYvlx^B hYa ,p88%\7 v܄ ,8 :W^)|uqaA=aْ nX͂z|uH(lXɂ@&T 6ѹA% $*ʶOa$:FǮ&PH(GjP pDA"}?jP !C=%I◓uuO1|jјh6_4M7py;!&ƥ7͍淊L$L`+ z̟I&AF $$)ͨ?€H""(aL"d$TO,0=M\PS-,ѕj1)(*.BYqQA!/i5H!h"_^MIENDB`dvcs-autosync-0.5/icons/48x48/0000755000000000000000000000000011625302736012765 5ustar dvcs-autosync-0.5/icons/48x48/dvcs-autosync.png0000644000000000000000000000354711625302736016306 0ustar PNG  IHDR00W.IDATxISGV!J{.) |1U.!x,BB" fU "xKmjfzd1Iz ~o"5nT#=8, %($A'1T/z8}IDzA7uQN= F]tƣev-ꨀ J۷tvvF_"/3X,VnhN> ͛7E BC~+˗/iwwަ/^p8cEc ) ҉\~5$V.Ap ^ff 4nFOkIB5b%%.įqVWWQki`_=IB$VhI8XYY?1+B`Ai+(L( ʂ/%yN.#?#,{0Y,T\hA^0$2t*ߡ{Uw1V ,D/--q,!vl0 @GaHm#tCkEs9vGm;"CzO0??OVEGsS#Й"Yz6Ks455ICij426VuEaբ5ߛ,&O)J޽>V1|72SV+ πnu D;ÄH$nsXfJcxY=r D!1ܷXMTYuHP8jE (U lq ;bVgTUSybuR!V'ʨ]<Cm  hW!I6UEN+ ) eZv]m !J ^6kd&'y} v.{6Um J焴ГGEfggt pGXmjWJHM`-`?l3C47[|~,]؛h9&#+4l0[a4 x}Bm<ŖAɈ2qLJꈦ&@'KmN!V'C!ﹲlRd^ENMI 'bo)djTh -@nC,_ ĂwDqҡhhlP@Њ<>ׅ~:8,@S7v# ^mɒ$\7Ц zt9#]FRYvcRiZ\>6:+̀'KpQ9`rz1|,T1eiN,IEѮg!;~v:t}6٫yki0.*=]Zx4 Whhd Izhsk4„ lVB\$/!s@w8|`4⁶%0FTP?N{ZT1 a@ЊBڀ@ M%4`6o1Rh{]-^=PqccM],~4K_P" Yxz>3ƍ͍/WJ>3p ײnݺuv z Sw> R}Щgkp(\> HF(xVpCIENDB`dvcs-autosync-0.5/icons/8x8/0000755000000000000000000000000011625302736012615 5ustar dvcs-autosync-0.5/icons/8x8/dvcs-autosync.png0000644000000000000000000000031411625302736016123 0ustar PNG  IHDRIDATxuK 0EyABbOcMR5dj N^AAwAV(eU#X}+)c $-W | v)Xk1MS#$ka|pQ9˲M֤q@xs4ME0s gtӵ?IENDB`dvcs-autosync-0.5/jabberbot.py0000644000000000000000000005077611625302736013376 0ustar #!/usr/bin/python # -*- coding: utf-8 -*- # JabberBot: A simple jabber/xmpp bot framework # Copyright (c) 2007-2011 Thomas Perl # # This program 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; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # """A simple framework for creating Jabber/XMPP bots and services""" import os import re import sys try: import xmpp except ImportError: print >>sys.stderr, 'You need to install xmpppy from http://xmpppy.sf.net/.' sys.exit(-1) import time import inspect import logging import traceback __author__ = 'Thomas Perl ' __version__ = '0.13' __website__ = 'http://thp.io/2007/python-jabberbot/' __license__ = 'GPLv3 or later' def botcmd(*args, **kwargs): """Decorator for bot command functions""" def decorate(func, hidden=False, name=None): setattr(func, '_jabberbot_command', True) setattr(func, '_jabberbot_hidden', hidden) setattr(func, '_jabberbot_command_name', name or func.__name__) return func if len(args): return decorate(args[0], **kwargs) else: return lambda func: decorate(func, **kwargs) class JabberBot(object): AVAILABLE, AWAY, CHAT, DND, XA, OFFLINE = None, 'away', 'chat', 'dnd', 'xa', 'unavailable' MSG_AUTHORIZE_ME = 'Hey there. You are not yet on my roster. Authorize my request and I will do the same.' MSG_NOT_AUTHORIZED = 'You did not authorize my subscription request. Access denied.' PING_FREQUENCY = 0 # Set to the number of seconds, e.g. 60. PING_TIMEOUT = 2 # Seconds to wait for a response. def __init__(self, username, password, res=None, debug=False, privatedomain=False, acceptownmsgs=False): """Initializes the jabber bot and sets up commands. If privatedomain is provided, it should be either True to only allow subscriptions from the same domain as the bot or a string that describes the domain for which subscriptions are accepted (e.g. 'jabber.org'). If acceptownmsgs it set to True, this bot will accept messages from the same JID that the bot itself has. This is useful when using JabberBot with a single Jabber account and multiple instances that want to talk to each other. """ self.__debug = debug self.log = logging.getLogger(__name__) self.__username = username self.__password = password self.jid = xmpp.JID(self.__username) self.res = (res or self.__class__.__name__) self.conn = None self.__finished = False self.__show = None self.__status = None self.__seen = {} self.__threads = {} self.__lastping = time.time() self.__privatedomain = privatedomain self.__acceptownmsgs = acceptownmsgs self.commands = {} for name, value in inspect.getmembers(self): if inspect.ismethod(value) and getattr(value, '_jabberbot_command', False): name = getattr(value, '_jabberbot_command_name') self.log.debug('Registered command: %s' % name) self.commands[name] = value self.roster = None ################################ def _send_status(self): self.conn.send(xmpp.dispatcher.Presence(show=self.__show, status=self.__status)) def __set_status(self, value): if self.__status != value: self.__status = value self._send_status() def __get_status(self): return self.__status status_message = property(fget=__get_status, fset=__set_status) def __set_show(self, value): if self.__show != value: self.__show = value self._send_status() def __get_show(self): return self.__show status_type = property(fget=__get_show, fset=__set_show) ################################ def connect( self): if not self.conn: if self.__debug: conn = xmpp.Client(self.jid.getDomain()) else: conn = xmpp.Client(self.jid.getDomain(), debug = []) conres = conn.connect() if not conres: self.log.error('unable to connect to server %s.' % self.jid.getDomain()) return None if conres<>'tls': self.log.warning('unable to establish secure connection - TLS failed!') authres = conn.auth(self.jid.getNode(), self.__password, self.res) if not authres: self.log.error('unable to authorize with server.') return None if authres<>'sasl': self.log.warning("unable to perform SASL auth os %s. Old authentication method used!" % self.jid.getDomain()) conn.sendInitPresence() self.conn = conn self.roster = self.conn.Roster.getRoster() self.log.info('*** roster ***') for contact in self.roster.getItems(): self.log.info(' %s' % contact) self.log.info('*** roster ***') self.conn.RegisterHandler('message', self.callback_message) self.conn.RegisterHandler('presence', self.callback_presence) return self.conn def join_room(self, room, username=None): """Join the specified multi-user chat room""" if username is None: username = self.__username.split('@')[0] my_room_JID = '/'.join((room, username)) self.connect().send(xmpp.Presence(to=my_room_JID)) def quit( self): """Stop serving messages and exit. I find it is handy for development to run the jabberbot in a 'while true' loop in the shell, so whenever I make a code change to the bot, I send the 'reload' command, which I have mapped to call self.quit(), and my shell script relaunches the new version. """ self.__finished = True def send_message(self, mess): """Send an XMPP message""" self.connect().send(mess) def send_tune(self, song, debug=False): """Set information about the currently played tune Song is a dictionary with keys: file, title, artist, album, pos, track, length, uri. For details see . """ NS_TUNE = 'http://jabber.org/protocol/tune' iq = xmpp.Iq(typ='set') iq.setFrom(self.jid) iq.pubsub = iq.addChild('pubsub', namespace = xmpp.NS_PUBSUB) iq.pubsub.publish = iq.pubsub.addChild('publish', attrs = { 'node' : NS_TUNE }) iq.pubsub.publish.item = iq.pubsub.publish.addChild('item', attrs= { 'id' : 'current' }) tune = iq.pubsub.publish.item.addChild('tune') tune.setNamespace(NS_TUNE) title = None if song.has_key('title'): title = song['title'] elif song.has_key('file'): title = os.path.splitext(os.path.basename(song['file']))[0] if title is not None: tune.addChild('title').addData(title) if song.has_key('artist'): tune.addChild('artist').addData(song['artist']) if song.has_key('album'): tune.addChild('source').addData(song['album']) if song.has_key('pos') and song['pos'] > 0: tune.addChild('track').addData(str(song['pos'])) if song.has_key('time'): tune.addChild('length').addData(str(song['time'])) if song.has_key('uri'): tune.addChild('uri').addData(song['uri']) if debug: print 'Sending tune:', iq.__str__().encode('utf8') self.conn.send(iq) def send(self, user, text, in_reply_to=None, message_type='chat'): """Sends a simple message to the specified user.""" mess = self.build_message(text) mess.setTo(user) if in_reply_to: mess.setThread(in_reply_to.getThread()) mess.setType(in_reply_to.getType()) else: mess.setThread(self.__threads.get(user, None)) mess.setType(message_type) self.send_message(mess) def send_simple_reply(self, mess, text, private=False): """Send a simple response to a message""" self.send_message( self.build_reply(mess,text, private) ) def build_reply(self, mess, text=None, private=False): """Build a message for responding to another message. Message is NOT sent""" response = self.build_message(text) if private: response.setTo(mess.getFrom()) response.setType('chat') else: response.setTo(mess.getFrom().getStripped()) response.setType(mess.getType()) response.setThread(mess.getThread()) return response def build_message(self, text): """Builds an xhtml message without attributes.""" text_plain = re.sub(r'<[^>]+>', '', text) message = xmpp.protocol.Message(body=text_plain) if text_plain != text: html = xmpp.Node('html', {'xmlns': 'http://jabber.org/protocol/xhtml-im'}) try: html.addChild(node=xmpp.simplexml.XML2Node("" + text.encode('utf-8') + "")) message.addChild(node=html) except Exception, e: # Didn't work, incorrect markup or something. # print >> sys.stderr, e, text message = xmpp.protocol.Message(body=text_plain) return message def get_sender_username(self, mess): """Extract the sender's user name from a message""" type = mess.getType() jid = mess.getFrom() if type == "groupchat": username = jid.getResource() elif type == "chat": username = jid.getNode() else: username = "" return username def status_type_changed(self, jid, new_status_type): """Callback for tracking status types (available, away, offline, ...)""" self.log.debug('user %s changed status to %s' % (jid, new_status_type)) def status_message_changed(self, jid, new_status_message): """Callback for tracking status messages (the free-form status text)""" self.log.debug('user %s updated text to %s' % (jid, new_status_message)) def broadcast(self, message, only_available=False): """Broadcast a message to all users 'seen' by this bot. If the parameter 'only_available' is True, the broadcast will not go to users whose status is not 'Available'.""" for jid, (show, status) in self.__seen.items(): if not only_available or show is self.AVAILABLE: self.send(jid, message) def callback_presence(self, conn, presence): self.__lastping = time.time() jid, type_, show, status = presence.getFrom(), \ presence.getType(), presence.getShow(), \ presence.getStatus() if self.jid.bareMatch(jid) and not self.__acceptownmsgs: # Ignore our own presence messages return if type_ is None: # Keep track of status message and type changes old_show, old_status = self.__seen.get(jid, (self.OFFLINE, None)) if old_show != show: self.status_type_changed(jid, show) if old_status != status: self.status_message_changed(jid, status) self.__seen[jid] = (show, status) elif type_ == self.OFFLINE and jid in self.__seen: # Notify of user offline status change del self.__seen[jid] self.status_type_changed(jid, self.OFFLINE) try: subscription = self.roster.getSubscription(unicode(jid.__str__())) except KeyError, e: # User not on our roster subscription = None except AttributeError, e: # Recieved presence update before roster built return if type_ == 'error': self.log.error(presence.getError()) self.log.debug('Got presence: %s (type: %s, show: %s, status: %s, subscription: %s)' % (jid, type_, show, status, subscription)) # If subscription is private, disregard anything not from the private domain if self.__privatedomain and type_ in ('subscribe', 'subscribed', 'unsubscribe'): if self.__privatedomain == True: # Use the bot's domain domain = self.jid.getDomain() else: # Use the specified domain domain = self.__privatedomain # Check if the sender is in the private domain user_domain = jid.getDomain() if domain != user_domain: self.log.info('Ignoring subscribe request: %s does not match private domain (%s)' % (user_domain, domain)) return if type_ == 'subscribe': # Incoming presence subscription request if subscription in ('to', 'both', 'from'): self.roster.Authorize(jid) self._send_status() if subscription not in ('to', 'both'): self.roster.Subscribe(jid) if subscription in (None, 'none'): self.send(jid, self.MSG_AUTHORIZE_ME) elif type_ == 'subscribed': # Authorize any pending requests for that JID self.roster.Authorize(jid) elif type_ == 'unsubscribed': # Authorization was not granted self.send(jid, self.MSG_NOT_AUTHORIZED) self.roster.Unauthorize(jid) def callback_message( self, conn, mess): """Messages sent to the bot will arrive here. Command handling + routing is done in this function.""" self.__lastping = time.time() # Prepare to handle either private chats or group chats type = mess.getType() jid = mess.getFrom() props = mess.getProperties() text = mess.getBody() username = self.get_sender_username(mess) if type not in ("groupchat", "chat"): self.log.debug("unhandled message type: %s" % type) return self.log.debug("*** props = %s" % props) self.log.debug("*** jid = %s" % jid) self.log.debug("*** username = %s" % username) self.log.debug("*** type = %s" % type) self.log.debug("*** text = %s" % text) # Ignore messages from before we joined if xmpp.NS_DELAY in props: return # Ignore messages from myself if username == self.__username: return # If a message format is not supported (eg. encrypted), txt will be None if not text: return # Ignore messages from users not seen by this bot if jid not in self.__seen: self.log.info('Ignoring message from unseen guest: %s' % jid) self.log.debug("I've seen: %s" % ["%s" % x for x in self.__seen.keys()]) return # Remember the last-talked-in thread for replies self.__threads[jid] = mess.getThread() if ' ' in text: command, args = text.split(' ', 1) else: command, args = text, '' cmd = command.lower() self.log.debug("*** cmd = %s" % cmd) if self.commands.has_key(cmd): try: reply = self.commands[cmd](mess, args) except Exception, e: reply = traceback.format_exc(e) self.log.exception('An error happened while processing a message ("%s") from %s: %s"' % (text, jid, reply)) else: # In private chat, it's okay for the bot to always respond. # In group chat, the bot should silently ignore commands it # doesn't understand or aren't handled by unknown_command(). default_reply = 'Unknown command: "%s". Type "help" for available commands.blubb!' % cmd if type == "groupchat": default_reply = None reply = self.unknown_command( mess, cmd, args) if reply is None: reply = default_reply if reply: self.send_simple_reply(mess,reply) def unknown_command(self, mess, cmd, args): """Default handler for unknown commands Override this method in derived class if you want to trap some unrecognized commands. If 'cmd' is handled, you must return some non-false value, else some helpful text will be sent back to the sender. """ return None def top_of_help_message(self): """Returns a string that forms the top of the help message Override this method in derived class if you want to add additional help text at the beginning of the help message. """ return "" def bottom_of_help_message(self): """Returns a string that forms the bottom of the help message Override this method in derived class if you want to add additional help text at the end of the help message. """ return "" @botcmd def help(self, mess, args): """Returns a help string listing available options. Automatically assigned to the "help" command.""" if not args: if self.__doc__: description = self.__doc__.strip() else: description = 'Available commands:' usage = '\n'.join(sorted([ '%s: %s' % (name, (command.__doc__.strip() or '(undocumented)').split('\n', 1)[0]) for (name, command) in self.commands.iteritems() if name != 'help' and not command._jabberbot_hidden ])) usage = usage + '\n\nType help to get more info about that specific command.' else: description = '' if args in self.commands: usage = self.commands[args].__doc__.strip() or 'undocumented' else: usage = 'That command is not defined.' top = self.top_of_help_message() bottom = self.bottom_of_help_message() if top : top = "%s\n\n" % top if bottom: bottom = "\n\n%s" % bottom return '%s%s\n\n%s%s' % ( top, description, usage, bottom ) def idle_proc( self): """This function will be called in the main loop.""" self._idle_ping() def _idle_ping(self): """Pings the server, calls on_ping_timeout() on no response. To enable set self.PING_FREQUENCY to a value higher than zero. """ if self.PING_FREQUENCY and time.time() - self.__lastping > self.PING_FREQUENCY: self.__lastping = time.time() #logging.debug('Pinging the server.') ping = xmpp.Protocol('iq',typ='get',payload=[xmpp.Node('ping',attrs={'xmlns':'urn:xmpp:ping'})]) try: res = self.conn.SendAndWaitForResponse(ping, self.PING_TIMEOUT) #logging.debug('Got response: ' + str(res)) if res is None: self.on_ping_timeout() except IOError, e: logging.error('Error pinging the server: %s, treating as ping timeout.' % e) self.on_ping_timeout() def on_ping_timeout(self): logging.info('Terminating due to PING timeout.') self.quit() def shutdown(self): """This function will be called when we're done serving Override this method in derived class if you want to do anything special at shutdown. """ pass def serve_forever( self, connect_callback = None, disconnect_callback = None): """Connects to the server and handles messages.""" conn = self.connect() if conn: self.log.info('bot connected. serving forever.') else: self.log.warn('could not connect to server - aborting.') return if connect_callback: connect_callback() self.__lastping = time.time() while not self.__finished: try: conn.Process(1) self.idle_proc() except KeyboardInterrupt: self.log.info('bot stopped by user request. shutting down.') break self.shutdown() if disconnect_callback: disconnect_callback() dvcs-autosync-0.5/org.eclipse.core.resources.prefs0000644000000000000000000000016611625302736017271 0ustar #Thu May 12 17:31:06 CEST 2011 eclipse.preferences.version=1 encoding/dvcs-autosync=utf-8 encoding/jabberbot.py=utf-8 dvcs-autosync-0.5/setup.py0000644000000000000000000000541411625302736012571 0ustar #!/usr/bin/python # Setup for dvcs-autosync by Rene Mayrhofer # Ideas for setup script taken from jabberbot setup.py by Thomas Perl from distutils.core import setup import os import re import sys # the package name SCRIPT = 'dvcs-autosync' keys = ('__version__', '__website__', '__license__', '__author__') options = dict() sc = open(SCRIPT) sclines = sc.readlines() for line in sclines: if not line.strip(): # skip empty or space padded lines continue if re.compile('^#').search(line) is not None: # skip commented lines continue kvp = line.strip().split('=') if kvp[0].strip() in keys: options[kvp[0].strip(' \'')] = kvp[1].strip(' \'') # These metadata fields are simply taken from the script VERSION = options['__version__'] WEBSITE = options['__website__'] LICENSE = options['__license__'] # Extract name and e-mail ("Firstname Lastname ") AUTHOR, EMAIL = re.match(r'(.*) <(.*)>', options['__author__']).groups() setup(name=SCRIPT, version=VERSION, author=AUTHOR, author_email=EMAIL, license=LICENSE, url=WEBSITE, scripts= [SCRIPT], # TODO: remove when we use the upstream Jabberbot data_files = [('/usr/share/' + SCRIPT, ['jabberbot.py', 'autosync-xdg-launcher.sh']), ('/usr/share/applications', [SCRIPT + '.desktop']), ('/usr/share/icons/hicolor/8x8/apps', ['icons/8x8/dvcs-autosync.png']), ('/usr/share/icons/hicolor/16x16/apps', ['icons/16x16/dvcs-autosync.png']), ('/usr/share/icons/hicolor/22x22/apps', ['icons/22x22/dvcs-autosync.png']), ('/usr/share/icons/hicolor/32x32/apps', ['icons/32x32/dvcs-autosync.png']), ('/usr/share/icons/hicolor/48x48/apps', ['icons/48x48/dvcs-autosync.png'])], description= 'Automatic synchronization of distributed version control repositories', download_url= 'https://gitorious.org/dvcs-autosync', long_description= 'dvcs-autosync is an open source replacement for Dropbox/Wuala/Box.net/etc. based on distributed version control systems (DVCS). It offers nearly instantaneous mutual updates when a file is added or changed on one side but with the added benefit of (local, distributed) versioning and that it does not rely on a centralized service provider, but can be used with any DVCS hosting option including a completely separate server. Synchronization of directories is based on DVCS repositories. Git is used for main development and is being tested most thoroughly as the backend storage, but other DVCS such as Mercurial are also supported. A single Python script monitors the configured directory for live changes, commits these changes to the DVCS (such as git) and synchronizes with other instances using XMPP messages.', )