|
2652
|
1 """File System Proxy.
|
|
|
2
|
|
|
3 Provide an OS-neutral view on a file system, locally or remotely.
|
|
|
4 The functionality is geared towards implementing some sort of
|
|
|
5 rdist-like utility between a Mac and a UNIX system.
|
|
|
6
|
|
|
7 The module defines three classes:
|
|
|
8
|
|
|
9 FSProxyLocal -- used for local access
|
|
|
10 FSProxyServer -- used on the server side of remote access
|
|
|
11 FSProxyClient -- used on the client side of remote access
|
|
|
12
|
|
|
13 The remote classes are instantiated with an IP address and an optional
|
|
|
14 verbosity flag.
|
|
|
15 """
|
|
|
16
|
|
|
17 import server
|
|
|
18 import client
|
|
|
19 import md5
|
|
|
20 import os
|
|
|
21 import fnmatch
|
|
|
22 from stat import *
|
|
|
23 import time
|
|
|
24 import fnmatch
|
|
|
25
|
|
|
26 if os.name == 'mac':
|
|
|
27 import macfs
|
|
|
28 maxnamelen = 31
|
|
|
29 else:
|
|
|
30 macfs = None
|
|
|
31 maxnamelen = 255
|
|
|
32
|
|
|
33 skipnames = (os.curdir, os.pardir)
|
|
|
34
|
|
|
35
|
|
|
36 class FSProxyLocal:
|
|
|
37
|
|
|
38 def __init__(self):
|
|
|
39 self._dirstack = []
|
|
|
40 self._ignore = ['*.pyc'] + self._readignore()
|
|
|
41
|
|
|
42 def _close(self):
|
|
|
43 while self._dirstack:
|
|
|
44 self.back()
|
|
|
45
|
|
|
46 def _readignore(self):
|
|
|
47 file = self._hide('ignore')
|
|
|
48 try:
|
|
|
49 f = open(file)
|
|
|
50 except IOError:
|
|
|
51 file = self._hide('synctree.ignorefiles')
|
|
|
52 try:
|
|
|
53 f = open(file)
|
|
|
54 except IOError:
|
|
|
55 return []
|
|
|
56 ignore = []
|
|
|
57 while 1:
|
|
|
58 line = f.readline()
|
|
|
59 if not line: break
|
|
|
60 if line[-1] == '\n': line = line[:-1]
|
|
|
61 ignore.append(line)
|
|
|
62 f.close()
|
|
|
63 return ignore
|
|
|
64
|
|
|
65 def _hidden(self, name):
|
|
|
66 if os.name == 'mac':
|
|
|
67 return name[0] == '(' and name[-1] == ')'
|
|
|
68 else:
|
|
|
69 return name[0] == '.'
|
|
|
70
|
|
|
71 def _hide(self, name):
|
|
|
72 if os.name == 'mac':
|
|
|
73 return '(%s)' % name
|
|
|
74 else:
|
|
|
75 return '.%s' % name
|
|
|
76
|
|
|
77 def visible(self, name):
|
|
|
78 if len(name) > maxnamelen: return 0
|
|
|
79 if name[-1] == '~': return 0
|
|
|
80 if name in skipnames: return 0
|
|
|
81 if self._hidden(name): return 0
|
|
|
82 head, tail = os.path.split(name)
|
|
|
83 if head or not tail: return 0
|
|
|
84 if macfs:
|
|
|
85 if os.path.exists(name) and not os.path.isdir(name):
|
|
|
86 try:
|
|
|
87 fs = macfs.FSSpec(name)
|
|
|
88 c, t = fs.GetCreatorType()
|
|
|
89 if t != 'TEXT': return 0
|
|
|
90 except macfs.error, msg:
|
|
|
91 print "***", name, msg
|
|
|
92 return 0
|
|
|
93 else:
|
|
|
94 if os.path.islink(name): return 0
|
|
|
95 if '\0' in open(name, 'rb').read(512): return 0
|
|
|
96 for ign in self._ignore:
|
|
|
97 if fnmatch.fnmatch(name, ign): return 0
|
|
|
98 return 1
|
|
|
99
|
|
|
100 def check(self, name):
|
|
|
101 if not self.visible(name):
|
|
|
102 raise os.error, "protected name %s" % repr(name)
|
|
|
103
|
|
|
104 def checkfile(self, name):
|
|
|
105 self.check(name)
|
|
|
106 if not os.path.isfile(name):
|
|
|
107 raise os.error, "not a plain file %s" % repr(name)
|
|
|
108
|
|
|
109 def pwd(self):
|
|
|
110 return os.getcwd()
|
|
|
111
|
|
|
112 def cd(self, name):
|
|
|
113 self.check(name)
|
|
|
114 save = os.getcwd(), self._ignore
|
|
|
115 os.chdir(name)
|
|
|
116 self._dirstack.append(save)
|
|
|
117 self._ignore = self._ignore + self._readignore()
|
|
|
118
|
|
|
119 def back(self):
|
|
|
120 if not self._dirstack:
|
|
|
121 raise os.error, "empty directory stack"
|
|
|
122 dir, ignore = self._dirstack[-1]
|
|
|
123 os.chdir(dir)
|
|
|
124 del self._dirstack[-1]
|
|
|
125 self._ignore = ignore
|
|
|
126
|
|
|
127 def _filter(self, files, pat = None):
|
|
|
128 if pat:
|
|
|
129 def keep(name, pat = pat):
|
|
|
130 return fnmatch.fnmatch(name, pat)
|
|
|
131 files = filter(keep, files)
|
|
|
132 files = filter(self.visible, files)
|
|
|
133 files.sort()
|
|
|
134 return files
|
|
|
135
|
|
|
136 def list(self, pat = None):
|
|
|
137 files = os.listdir(os.curdir)
|
|
|
138 return self._filter(files, pat)
|
|
|
139
|
|
|
140 def listfiles(self, pat = None):
|
|
|
141 files = os.listdir(os.curdir)
|
|
|
142 files = filter(os.path.isfile, files)
|
|
|
143 return self._filter(files, pat)
|
|
|
144
|
|
|
145 def listsubdirs(self, pat = None):
|
|
|
146 files = os.listdir(os.curdir)
|
|
|
147 files = filter(os.path.isdir, files)
|
|
|
148 return self._filter(files, pat)
|
|
|
149
|
|
|
150 def exists(self, name):
|
|
|
151 return self.visible(name) and os.path.exists(name)
|
|
|
152
|
|
|
153 def isdir(self, name):
|
|
|
154 return self.visible(name) and os.path.isdir(name)
|
|
|
155
|
|
|
156 def islink(self, name):
|
|
|
157 return self.visible(name) and os.path.islink(name)
|
|
|
158
|
|
|
159 def isfile(self, name):
|
|
|
160 return self.visible(name) and os.path.isfile(name)
|
|
|
161
|
|
|
162 def sum(self, name):
|
|
|
163 self.checkfile(name)
|
|
|
164 BUFFERSIZE = 1024*8
|
|
|
165 f = open(name)
|
|
|
166 sum = md5.new()
|
|
|
167 while 1:
|
|
|
168 buffer = f.read(BUFFERSIZE)
|
|
|
169 if not buffer:
|
|
|
170 break
|
|
|
171 sum.update(buffer)
|
|
|
172 return sum.digest()
|
|
|
173
|
|
|
174 def size(self, name):
|
|
|
175 self.checkfile(name)
|
|
|
176 return os.stat(name)[ST_SIZE]
|
|
|
177
|
|
|
178 def mtime(self, name):
|
|
|
179 self.checkfile(name)
|
|
|
180 return time.localtime(os.stat(name)[ST_MTIME])
|
|
|
181
|
|
|
182 def stat(self, name):
|
|
|
183 self.checkfile(name)
|
|
|
184 size = os.stat(name)[ST_SIZE]
|
|
|
185 mtime = time.localtime(os.stat(name)[ST_MTIME])
|
|
|
186 return size, mtime
|
|
|
187
|
|
|
188 def info(self, name):
|
|
|
189 sum = self.sum(name)
|
|
|
190 size = os.stat(name)[ST_SIZE]
|
|
|
191 mtime = time.localtime(os.stat(name)[ST_MTIME])
|
|
|
192 return sum, size, mtime
|
|
|
193
|
|
|
194 def _list(self, function, list):
|
|
|
195 if list is None:
|
|
|
196 list = self.listfiles()
|
|
|
197 res = []
|
|
|
198 for name in list:
|
|
|
199 try:
|
|
|
200 res.append((name, function(name)))
|
|
|
201 except (os.error, IOError):
|
|
|
202 res.append((name, None))
|
|
|
203 return res
|
|
|
204
|
|
|
205 def sumlist(self, list = None):
|
|
|
206 return self._list(self.sum, list)
|
|
|
207
|
|
|
208 def statlist(self, list = None):
|
|
|
209 return self._list(self.stat, list)
|
|
|
210
|
|
|
211 def mtimelist(self, list = None):
|
|
|
212 return self._list(self.mtime, list)
|
|
|
213
|
|
|
214 def sizelist(self, list = None):
|
|
|
215 return self._list(self.size, list)
|
|
|
216
|
|
|
217 def infolist(self, list = None):
|
|
|
218 return self._list(self.info, list)
|
|
|
219
|
|
|
220 def _dict(self, function, list):
|
|
|
221 if list is None:
|
|
|
222 list = self.listfiles()
|
|
|
223 dict = {}
|
|
|
224 for name in list:
|
|
|
225 try:
|
|
|
226 dict[name] = function(name)
|
|
|
227 except (os.error, IOError):
|
|
|
228 pass
|
|
|
229 return dict
|
|
|
230
|
|
|
231 def sumdict(self, list = None):
|
|
|
232 return self.dict(self.sum, list)
|
|
|
233
|
|
|
234 def sizedict(self, list = None):
|
|
|
235 return self.dict(self.size, list)
|
|
|
236
|
|
|
237 def mtimedict(self, list = None):
|
|
|
238 return self.dict(self.mtime, list)
|
|
|
239
|
|
|
240 def statdict(self, list = None):
|
|
|
241 return self.dict(self.stat, list)
|
|
|
242
|
|
|
243 def infodict(self, list = None):
|
|
|
244 return self._dict(self.info, list)
|
|
|
245
|
|
|
246 def read(self, name, offset = 0, length = -1):
|
|
|
247 self.checkfile(name)
|
|
|
248 f = open(name)
|
|
|
249 f.seek(offset)
|
|
|
250 if length == 0:
|
|
|
251 data = ''
|
|
|
252 elif length < 0:
|
|
|
253 data = f.read()
|
|
|
254 else:
|
|
|
255 data = f.read(length)
|
|
|
256 f.close()
|
|
|
257 return data
|
|
|
258
|
|
|
259 def create(self, name):
|
|
|
260 self.check(name)
|
|
|
261 if os.path.exists(name):
|
|
|
262 self.checkfile(name)
|
|
|
263 bname = name + '~'
|
|
|
264 try:
|
|
|
265 os.unlink(bname)
|
|
|
266 except os.error:
|
|
|
267 pass
|
|
|
268 os.rename(name, bname)
|
|
|
269 f = open(name, 'w')
|
|
|
270 f.close()
|
|
|
271
|
|
|
272 def write(self, name, data, offset = 0):
|
|
|
273 self.checkfile(name)
|
|
|
274 f = open(name, 'r+')
|
|
|
275 f.seek(offset)
|
|
|
276 f.write(data)
|
|
|
277 f.close()
|
|
|
278
|
|
|
279 def mkdir(self, name):
|
|
|
280 self.check(name)
|
|
|
281 os.mkdir(name, 0777)
|
|
|
282
|
|
|
283 def rmdir(self, name):
|
|
|
284 self.check(name)
|
|
|
285 os.rmdir(name)
|
|
|
286
|
|
|
287
|
|
|
288 class FSProxyServer(FSProxyLocal, server.Server):
|
|
|
289
|
|
|
290 def __init__(self, address, verbose = server.VERBOSE):
|
|
|
291 FSProxyLocal.__init__(self)
|
|
|
292 server.Server.__init__(self, address, verbose)
|
|
|
293
|
|
|
294 def _close(self):
|
|
|
295 server.Server._close(self)
|
|
|
296 FSProxyLocal._close(self)
|
|
|
297
|
|
|
298 def _serve(self):
|
|
|
299 server.Server._serve(self)
|
|
|
300 # Retreat into start directory
|
|
|
301 while self._dirstack: self.back()
|
|
|
302
|
|
|
303
|
|
|
304 class FSProxyClient(client.Client):
|
|
|
305
|
|
|
306 def __init__(self, address, verbose = client.VERBOSE):
|
|
|
307 client.Client.__init__(self, address, verbose)
|
|
|
308
|
|
|
309
|
|
|
310 def test():
|
|
|
311 import string
|
|
|
312 import sys
|
|
|
313 if sys.argv[1:]:
|
|
|
314 port = string.atoi(sys.argv[1])
|
|
|
315 else:
|
|
|
316 port = 4127
|
|
|
317 proxy = FSProxyServer(('', port))
|
|
|
318 proxy._serverloop()
|
|
|
319
|
|
|
320
|
|
|
321 if __name__ == '__main__':
|
|
|
322 test()
|
