vlt sync cq5 crap

urls.txt

http://bpaste.net/show/zDKaQZ7JZ8nLxqsyNW5s/
http://bpaste.net/show/2JFuadtSGb5xash7ojxm/

vlts.py

import time
import os
import sys
import collections
import re
import atexit

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

IGNORE=['.vlt', '.svn', '/svn-', '/vlt-']

class Vlt(object):
    def __init__(self, vltcmd='vlt'):
        self.vltcmd = vltcmd

    def ci(self, files):
        print('vlt ci %s' % (' '.join(files)))
    
    def add(self, files):
        print('vlt add %s' % (' '.join(files)))

    def rm(self, files):
        print('vlt rm %s' % (' '.join(files)))



class VltSync(FileSystemEventHandler):
    def __init__(self, vlt, ignore=IGNORE):
        super(VltSync, self).__init__()

        self.vlt = vlt
        self.ignore = ignore
        self.events = collections.deque()
        self.curr_event = None

    def _should_ignore(self, event):
        for x in self.ignore:
            if hasattr(event, 'dest_path'):
                #mv event affects ignored destination.
                if event.dest_path.find(x) >= 0:
                    return True
            elif event.src_path.find(x) >= 0:
                #non-mv event affects ignored source.
                return True
        return False


    def process(self, event):
        if not self._should_ignore(event):
            self.events.append(event)
            self.commit()

    def commit(self):
        print('here')
        if self.curr_event is None:
            self.curr_event = self.events.popleft()
            print(self.curr_event)
            self.curr_event = None
        else:
            print('cannot commit becase of', self.curr_event)


    def on_created(self, event):
        self.process(event)

    def on_deleted(self, event):
        self.process(event)

    def on_modified(self, event):
        self.process(event)

    def on_moved(self, event):
        self.process(event)


class Main(object):
    def __init__(self, event_handler, observer, path):
        self.event_handler = event_handler
        self.observer = observer
        self.path = path

    def start(self):
        self.observer.schedule(self.event_handler, path=self.path, recursive=True)
        self.observer.start()

    def stop(self):
        self.observer.stop()
        self.observer.join()
        print('stopped')



def main(argv=sys.argv):
    path = os.path.abspath(argv[1])
    print('watching: %s' % path)

    event_handler = VltSync(Vlt())
    observer = Observer()

    runner = Main(event_handler, observer, path)
    atexit.register(runner.stop)

    runner.start()
    
    try:
        while ":q" != raw_input():
            pass
    except KeyboardInterrupt:
        pass



if __name__ == "__main__":
    main(sys.argv)

vlts_threading.py

import time
import os
import sys
import Queue
import threading

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler


TIMEOUT = 5


class Vlt(object):
    def __init__(self, vltcmd='vlt'):
        self.vltcmd = vltcmd

    def ci(self, files):
        print('vlt ci %s' % (' '.join(files)))

    def add(self, files):
        print('vlt add %s' % (' '.join(files)))

    def rm(self, files):
        print('vlt rm %s' % (' '.join(files)))



class VltSync(FileSystemEventHandler):
    def __init__(self):
        super(VltSync, self).__init__()

        self.events = Queue.Queue()
        self.event = threading.Event()
        self.curr_event = None

    def process(self, event):
        self.events.put(event)
        self.event.set()

    def on_created(self, event):
        print('created', event)
        self.process(event)

    def on_deleted(self, event):
        print('deleted', event)
        self.process(event)

    def on_modified(self, event):
        print('modified', event)
        self.process(event)

    def on_moved(self, event):
        print('moved', event)
        self.process(event)

def main(argv=sys.argv):
    path = os.path.abspath(argv[1])
    print('watching: %s' % path)

    event_handler = VltSync()
    observer = Observer()
    observer.schedule(event_handler, path=path, recursive=True)
    observer.start()

    while True:
        event_handler.event.wait()
        event_handler.event.clear()
        while event_handler.event.wait(TIMEOUT):
            event_handler.event.clear()

        try:
            while True:
                event = event_handler.events.get_nowait()
                print 'batch-processing', event
        except Queue.Empty:
            pass

    def commit(self):
        if self.curr_event is None:
            self.curr_event = self.events.popleft()
            self.process(self.curr_event)
            self.curr_event = None
        else:
            print('cannot commit becase of', self.curr_event)

    raw_input()
    observer.stop()
    observer.join() 



if __name__ == "__main__":
    main(sys.argv)

vlts_twisted.py

import sys

from twisted.python import log, filepath
from twisted.internet import defer, inotify


TIMEOUT = 3


class Watcher(object):

    def __init__(self, clock):
        self.clock = clock
        self.events = []
        self.timeout = None

    def notify(self, ignored, filepath, mask):
        self.events.append((filepath, mask))
        if self.timeout is None:
            self.timeout = self.clock.callLater(TIMEOUT, self.process)
        else:
            self.timeout.reset(TIMEOUT)

    def process(self):
        print 'batch processing fired'
        self.timeout = None
        events, self.events = self.events, []

        for event in events:
            print 'batch-processing', event


def main(reactor, path):
    watcher = Watcher(reactor)

    notifier = inotify.INotify()
    notifier.startReading()
    notifier.watch(filepath.FilePath(path), callbacks=[watcher.notify])


def start(argv):
    from twisted.internet import reactor

    d = defer.Deferred()
    reactor.callWhenRunning(d.callback, reactor)
    d.addCallback(main, argv[1])
    @d.addErrback
    def err(f):
        log.err(f)
        reactor.stop()

    reactor.run()


if __name__ == '__main__':
    start(sys.argv)