Demo/pdist/FSProxy.py

   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()