dotfiles/onchange.py at master · flycandy/dotfiles · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#!/usr/bin/env python3
"""
Usage:
    onchange.py
    onchange.py exec <folder> <cmd>
    onchange.py <watch>...

execute .onchange script when the parent folder changes
if a/.onchange exist, then if folder a changes, .onchange will be executed
it will be executed at most 1 time per 5 second

"""
import os
import threading
import time
import arrow
import logging
from docopt import docopt as docoptinit

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


class Runner:
    def __init__(self, folder):
        logging.info('watch folder {}'.format(folder))
        self.folder = folder
        self.observer = Observer()
        self.last_modify = arrow.now()
        self.last_change = arrow.now().replace(days=-1)

    class MyHandler(FileSystemEventHandler):
        def __init__(self, parent):
            self.parent = parent

        def on_created(self, event: FileSystemEvent):
            for ignore in ['.onchange', '.git', '.idea']:
                if event.src_path.find(ignore) >= 0:
                    # logging.info('ignore {}'.format(event))
                    return
            path = os.path.join(os.getcwd(), event.src_path)
            logging.info('do {} {}'.format(self.parent.folder, path))
            cmd = 'cd {} && chmod +x .onchange &&  ./.onchange {}'.format(self.parent.folder, path)
            os.system(cmd)
            logging.info('done {} {}'.format(self.parent.folder, path))

        def on_modified(self, event):
            for ignore in ['.onchange', '.git', '.idea']:
                if event.src_path.find(ignore) >= 0:
                    # logging.info('ignore {}'.format(event))
                    return
            # logging.info('Got it! {} {}'.format(event, arrow.now()))
            self.parent.last_modify = arrow.now()

    def execute(self):
        while True:
            if self.last_modify > self.last_change:
                self.last_change = self.last_modify
                time.sleep(0.1)
                # logging.info('execute script {}/.onchange'.format(self.folder))
                os.system('cd {} && chmod +x .onchange &&  ./.onchange'.format(self.folder))
                logging.info('done {}'.format(self.folder))
                os.system("osascript -e 'display notification \"Sync Done\"'")
            time.sleep(5)

    def start(self):
        event_handler = self.MyHandler(self)
        self.observer.schedule(event_handler, self.folder, recursive=True)
        self.observer.start()
        threading.Thread(target=self.execute, daemon=True).start()


class WatchSingleFolder:
    def __init__(self, folder, cmd):
        logging.info('watch folder {}'.format(folder))
        self.cmd = cmd
        self.folder = folder
        self.observer = Observer()
        self.last_modify = arrow.now()
        self.last_change = arrow.now().replace(days=-1)

    class MyHandler(FileSystemEventHandler):
        def __init__(self, parent):
            self.parent = parent

        def on_created(self, event: FileSystemEvent):
            for ignore in ['.onchange', '.git', '.idea']:
                if event.src_path.find(ignore) >= 0:
                    return
            print('changed', event)

        def on_modified(self, event):
            for ignore in ['.onchange', '.git', '.idea']:
                if event.src_path.find(ignore) >= 0:
                    return
            self.parent.last_modify = arrow.now()
            print('modify', event)

    def execute(self):
        while True:
            if self.last_modify > self.last_change:
                self.last_change = self.last_modify
                time.sleep(0.1)
                # logging.info('execute script {}/.onchange'.format(self.folder))
                print('do', self.cmd)
                os.system(self.cmd)
                print('done')
            time.sleep(5)

    def start(self):
        event_handler = self.MyHandler(self)
        self.observer.schedule(event_handler, self.folder, recursive=True)
        self.observer.start()
        threading.Thread(target=self.execute).start()


def main():
    docopt = docoptinit(__doc__)
    logging.basicConfig(level=logging.INFO, format='%(asctime)-15s  %(message)s')
    lst = []
    # for folder, folders, files in os.walk(os.path.expanduser('~/Dropbox/qb')):
    if not docopt['<watch>']:
        docopt['<watch>'] = ['.']
    print(docopt)
    if docopt['exec']:
        r = WatchSingleFolder(docopt['<folder>'], docopt['<cmd>'])
        r.start()
    else:
        for f in docopt['<watch>']:
            for folder, folders, files in os.walk(f):
                if '.onchange' in files:
                    # print(folder)
                    r = Runner(folder)
                    r.start()
                    lst.append(r)
                    # print(x)
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        for r in lst:
            r.observer.stop()
    for r in lst:
        r.observer.join()


if __name__ == "__main__":
    main()