wikifuse.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #
   4 # Copyright 2006, 2008, 2009 Nedko Arnaudov <nedko@arnaudov.name>
   5 # You can use this software for any purpose you want
   6 # Use it at your own risk
   7 # You are allowed to modify the code
   8 # You are disallowed to remove author credits from header
   9 #
  10 # FUSE filesystem for wiki
  11 #
  12 # Uses XML-RPC for accessing wiki
  13 # Documentation here: http://www.jspwiki.org/Wiki.jsp?page=WikiRPCInterface2
  14 #
  15 # Requires:
  16 #  FUSE python bindings (0.2 or later), available from FUSE project http://fuse.sourceforge.net/
  17 #  xmlrpclib, available since python 2.2
  18 #
  19 # Tested with:
  20 #  Editors: xemacs, vi
  21 #  FUSE lkm: one comming with 2.6.15, 2.6.23.1
  22 #  FUSE usermode: 2.5.2, 2.7.3
  23 #  Python: 2.4.2, 2.5.1
  24 #  Wiki engines: MoinMoinWiki 1.5.0, 1.6.3
  25 #
  26 # Expected to work with:
  27 #  Every editor (60%)
  28 #  Python >= 2.2 (99%)
  29 #  FUSE > 2.5.2 (70%)
  30 #  MoinMoinWiki > 1.5.0 (90%)
  31 #
  32 # If you improve this code, send a modified version to author please
  33 #
  34 ########################################################################################
  35
  36 example_config = """
  37 # example configuration file for wikifuse
  38 #
  39 # wikis is array of dictionaries
  40 # each dictionary represents one wiki server
  41 #
  42 # keys:
  43 #  * name - REQUIRED name of the wiki server, will be used as directory name
  44 #  * xmlrpc_url - REQUIRED xml-rpc url of the wiki server
  45 #  * auth - OPTIONAL authentication method.
  46 #
  47 # authentication methods and related keys:
  48 #  * 'moin_cookie' required keys:
  49 #   * user_id - moin internal moin user id. Look at your data/users directory in wiki instance to get exact value
  50 #  * 'moin_auth' required keys:
  51 #   * username - your moin username
  52 #   * password - your moin password
  53
  54 wikis = [
  55     {
  56     'name': 'example.com',
  57     'xmlrpc_url': 'http://wiki.example.com/moin.cgi?action=xmlrpc2',
  58     'auth': 'moin_cookie',
  59     'user_id': '1111111111.22.3333'
  60     },
  61     {
  62     'name': 'wiki_anon',
  63     'xmlrpc_url': 'http://wiki.example.com/moin.cgi/?action=xmlrpc2',
  64     },
  65     {
  66     'name': 'trac_http_basic',
  67     'xmlrpc_url': 'https://user:pass@wiki.example.com/login/xmlrpc',
  68     },
  69     {
  70     'name': 'example.org',
  71     'xmlrpc_url': 'http://wiki.example.org/wiki/moin.cgi/?action=xmlrpc2',
  72     'auth': 'moin_auth',
  73     'username': 'foo',
  74     'password': 'bar'
  75     }
  76     ]
  77 """
  78
  79 # Verbosity
  80 #
  81 # 0 - silent
  82 # 1 - errors
  83 # 2 - basic
  84 # 3 - debug
  85 verbosity = 2
  86
  87 import xmlrpclib
  88 import fuse
  89 import os, sys
  90 import xmlrpclib
  91 import types
  92 from errno import *
  93 from stat import *
  94 import locale
  95 import re
  96
  97 fuse.fuse_python_api = (0, 2)
  98
  99 out_charset = locale.getpreferredencoding()
 100 if out_charset == None:
 101     out_charset = "utf-8"
 102 page_coding = "utf-8"
 103
 104 #print("Using charset %s for stdout" % out_charset)
 105
 106 def printex(str):
 107     if type(str) != types.StringType and type(str) != types.UnicodeType:
 108         raise "trying to print non-string type %s" % type(str)
 109
 110     try:
 111         print str.encode(out_charset, "replace")
 112     except UnicodeDecodeError, e:
 113         print "---------------- cannot print: %s" % e
 114     except:
 115         print "---------------- cannot print: %s" % sys.exc_info()[0]
 116
 117 def log(str):
 118     printex(str)
 119
 120 def log_error(str):
 121     if verbosity >= 1:
 122         log(str)
 123
 124 def log_basic(str):
 125     if verbosity >= 2:
 126         log(str)
 127
 128 def log_debug(str):
 129     if verbosity >= 3:
 130         log(str)
 131
 132 class WikiServerProxy:
 133     def __init__(self, url, transport=None, prefix=""):
 134         # if available, strip username and password from url, because the self.url string is used in prints
 135         m = re.match(r"(https?://)([^:]+):([^@]+)@(.*)", url)
 136         if m != None:
 137             self.url = m.group(1) + m.group(4)
 138         else:
 139             self.url = url;
 140
 141         if verbosity >= 3:
 142             xmlrpc_verbose = 1
 143         else:
 144             xmlrpc_verbose = 0
 145
 146         self.xmlrpc = xmlrpclib.ServerProxy(url, verbose=xmlrpc_verbose, transport=transport)
 147         try:
 148             print self.url + ": introspection is supported"# + repr(self.xmlrpc.system.listMethods())
 149         except xmlrpclib.Fault, f:
 150             print self.url + ": introspection is not supported. code=%d (%s)" % (f.faultCode, f.faultString)
 151
 152         self.fnprefix = prefix
 153
 154     def cleanup(self):
 155         pass
 156
 157 # xml rpc proxy without authentication
 158 class WikiServerProxySimple(WikiServerProxy):
 159     def __init__(self, url, prefix=""):
 160         WikiServerProxy.__init__(self, url, prefix=prefix)
 161
 162     def __getattr__(self, name):
 163         #log("__getattr__ " + name)
 164         return self.function(self.xmlrpc, self.fnprefix + name)
 165
 166     class function:
 167         def __init__(self, xmlrpc, name):
 168             self.xmlrpc = xmlrpc
 169             self.name = name
 170
 171         def __call__(self, *args):
 172             #log("proxy call %s%s" % (self.name, repr(args)))
 173             func = self.xmlrpc.__getattr__(self.name)
 174             return func(*args)
 175
 176 # moin_cookie authentication (MoinMoinWiki)
 177 #
 178 # For this to work change server check for self.request.user.trusted to check for self.request.user.valid
 179 # The check is made in wikirpc.py, near line 362
 180 #
 181 # user_id is simply internal moin user id
 182 # Look at your data/users directory in wiki instance to get exact value
 183
 184 class WikiServerProxyMoinCookie(WikiServerProxy):
 185     def __init__(self, url, user_id, prefix=""):
 186         if url.startswith("https"):
 187             transport = self.safeTransport(user_id)
 188         else:
 189             transport = self.transport(user_id)
 190         WikiServerProxy.__init__(self, url, transport=transport, prefix=prefix)
 191
 192     def __getattr__(self, name):
 193         #log("__getattr__ " + name)
 194         return self.function(self.xmlrpc, self.fnprefix + name)
 195
 196     class function:
 197         def __init__(self, xmlrpc, name):
 198             self.xmlrpc = xmlrpc
 199             self.name = name
 200
 201         def __call__(self, *args):
 202             #log("proxy call %s%s" % (self.name, repr(args)))
 203             func = self.xmlrpc.__getattr__(self.name)
 204             return func(*args)
 205
 206     class transport(xmlrpclib.Transport):
 207         def __init__(self, user_id):
 208             xmlrpclib.Transport.__init__(self)
 209             self.user_id = user_id
 210
 211         def get_host_info(self, host):
 212             host, extra_headers, x509 = xmlrpclib.Transport.get_host_info(self, host)
 213
 214             if extra_headers == None:
 215                 extra_headers = []
 216             extra_headers.append(("Cookie", "MOIN_ID=" + self.user_id))
 217
 218             return host, extra_headers, x509
 219
 220     class safeTransport(xmlrpclib.SafeTransport):
 221         def __init__(self, user_id):
 222             xmlrpclib.SafeTransport.__init__(self)
 223             self.user_id = user_id
 224
 225         def get_host_info(self, host):
 226             host, extra_headers, x509 = xmlrpclib.SafeTransport.get_host_info(self, host)
 227
 228             if extra_headers == None:
 229                 extra_headers = []
 230             extra_headers.append(("Cookie", "MOIN_ID=" + self.user_id))
 231
 232             return host, extra_headers, x509
 233
 234 # MoinMoinWiki xmlrpc authentication
 235 #
 236 class WikiServerProxyMoinAuth(WikiServerProxy):
 237     def __init__(self, url, username, password, prefix=""):
 238         WikiServerProxy.__init__(self, url, prefix=prefix)
 239
 240         self.username = username
 241         self.password = password
 242         self.token = None
 243         self.check_token()
 244
 245     def __getattr__(self, name):
 246         #log("__getattr__ " + name)
 247         self.check_token()
 248         return self.function(self.xmlrpc, self.fnprefix + name, self.token)
 249
 250     def cleanup(self):
 251         if self.token:
 252             log_basic("Deleting moin auth token for '%s'" % self.url)
 253             assert self.xmlrpc.deleteAuthToken(self.token) == 'SUCCESS'
 254
 255     def check_token(self):
 256         # Verify that the token is valid by using it
 257         # and checking that the result is 'SUCCESS'.
 258         # The token should be valid for 15 minutes.
 259
 260         if self.token:
 261             try:
 262                 self.xmlrpc.applyAuthToken(self.token)
 263             except:
 264                 self.token = None
 265
 266         if not self.token:
 267             # refresh token
 268             log_basic("Getting new moin auth token for '%s'" % self.url)
 269             self.token = self.xmlrpc.getAuthToken(self.username, self.password)
 270
 271             if self.xmlrpc.applyAuthToken(self.token) != 'SUCCESS':
 272                 log_error("Invalid username/password when authenticating to '%s' (%s/%s)" % (url, username, password))
 273
 274     class function:
 275         def __init__(self, xmlrpc, name, token):
 276             self.xmlrpc = xmlrpc
 277             self.name = name
 278             self.token = token
 279
 280         def __call__(self, *args):
 281             #log("proxy call %s%s" % (self.name, repr(args)))
 282
 283             # build a multicall object that
 284             mcall = xmlrpclib.MultiCall(self.xmlrpc)
 285
 286             # first applies the token and
 287             mcall.applyAuthToken(self.token)
 288
 289             # then call the real function
 290             mcall.__getattr__(self.name)(*args)
 291
 292             # now execute the multicall
 293             results = mcall()
 294
 295             #log_basic(results[0])
 296
 297             try:
 298                 ret = results[1]
 299             except xmlrpclib.Fault, f:
 300                 ret = {'faultCode': f.faultCode, 'faultString': f.faultString}
 301
 302             return ret
 303
 304 class MyStat(fuse.Stat):
 305     def __init__(self):
 306         self.st_mode = 0
 307         self.st_ino = 0
 308         self.st_dev = 0
 309         self.st_nlink = 0
 310         self.st_uid = 0
 311         self.st_gid = 0
 312         self.st_size = 0
 313         self.st_atime = 0
 314         self.st_mtime = 0
 315         self.st_ctime = 0
 316
 317 class WikiServer:
 318     def __init__(self, name, proxy, put2=False):
 319         self.name = name
 320
 321         self.wikiproxy = proxy
 322
 323         self.put2 = put2
 324
 325         info  = "name: %s\n" % name
 326         info += "url: %s\n" % proxy.url
 327         info += "proxy: %s\n" % proxy.__class__.__name__
 328
 329         # test rpc
 330         #log("%10s: %s (%s)" % (name, self.wikiproxy.WhoAmI(), proxy.url))
 331
 332         try:
 333             whoami = self.wikiproxy.WhoAmI()
 334         except xmlrpclib.Fault, e:
 335             whoami = e
 336         except:
 337             whoami = sys.exc_info()[0]
 338
 339         info += "whoami: %s\n" % whoami
 340
 341         try:
 342             version = self.wikiproxy.getRPCVersionSupported()
 343         except xmlrpclib.Fault, e:
 344             version = e
 345         except:
 346             version = sys.exc_info()[0]
 347
 348         info += "wiki xml rpc version: %s\n" % version
 349
 350         self.pages = {}
 351         self.virt_pages = {}
 352         self.all = [unicode(x).encode(page_coding)
 353                     for x in self.wikiproxy.getAllPages()]
 354         info += "pages: %s\n%s" % (len(self.all),"\n".join(self.all))
 355
 356         self.virt_pages['_'] = info
 357         #self.virt_pages['cyr'] = u"ÐºÐ¸Ñ€Ð¸Ð��»Ð¸Ñ Ð��°"
 358
 359     def cleanup(self):
 360         self.wikiproxy.cleanup()
 361
 362     def readdir(self, offset):
 363         yield fuse.Direntry('.')
 364         yield fuse.Direntry('..')
 365
 366         for page in self.virt_pages.iterkeys():
 367             yield fuse.Direntry(page)
 368
 369         all = self.all
 370         for page in all:
 371             page = page.replace("/","%%")
 372             if page.find('/') == -1:
 373                 yield fuse.Direntry(page)
 374
 375     def getattr(self, path):
 376         log_basic("getattr \"%s\"" % path)
 377
 378         st = MyStat()
 379         st.st_nlink = 1
 380
 381         st.st_mode = S_IFREG | 0666
 382
 383         if self.virt_pages.has_key(path):
 384             st.st_size = len(self.virt_pages[path])
 385             return st
 386
 387         if self.pages.has_key(path):
 388             st.st_size = self.pages[path]['size']
 389             return st
 390
 391         if path.replace("%%","/") not in self.all:
 392             log_basic("not in all")
 393             return -ENOENT
 394
 395         info = self.wikiproxy.getPageInfo(path.replace("%%","/"))
 396         if info.has_key('faultCode'):
 397             log_error("getPageInfo(%s) failed" % path + repr(info))
 398             return -ENOENT
 399
 400         data = self.wikiproxy.getPage(path.replace("%%","/"))
 401         data = unicode(data).encode(out_charset)
 402         st.st_size = len(data)
 403
 404         return st
 405
 406     def open(self, path, flags):
 407         log_basic("open \"%s\" flags %u" % (path, flags))
 408
 409         if not self.pages.has_key(path):
 410             self.pages[path] = {}
 411
 412         if self.virt_pages.has_key(path):
 413             data = self.virt_pages[path]
 414             self.pages[path]['data'] = data
 415             self.pages[path]['size'] = len(data)
 416             self.pages[path]['modified'] = False
 417             return 0
 418
 419         data = self.wikiproxy.getPage(path.replace("%%","/"))
 420         data = unicode(data).encode(out_charset)
 421         if self.pages[path].has_key('size'):
 422             size = self.pages[path]['size']
 423             if size != len(data):
 424                 log_basic("Truncating to %u bytes" % size)
 425                 if size == 0:
 426                     data = ""
 427                 else:
 428                     data = data[size:]
 429                 self.pages[path]['modified'] = True
 430                 self.pages[path]['data'] = data
 431                 log_debug("\"%s\"" % data)
 432         else:
 433             size = len(data)
 434             log_basic("Updating size of '%s' to %u bytes" % (path, size))
 435             self.pages[path]['modified'] = False
 436         self.pages[path]['data'] = data
 437         self.pages[path]['size'] = size
 438         return 0
 439
 440     def read(self, path, length, offset):
 441         log_basic("read \"%s\" %u bytes, from offset %u" % (path, length, offset))
 442
 443         if offset + length > self.pages[path]['size']:
 444             length = self.pages[path]['size'] - offset
 445
 446         if length == 0:
 447             data = ""
 448         else:
 449             data = self.pages[path]['data'][offset:offset+length]
 450         log_debug("\"%s\"" % data)
 451         log_basic("data length: %u bytes" % len(data))
 452         log_basic("type: %s" % type(data))
 453         return data
 454
 455     def write(self, path, buf, offset):
 456         log_basic("write \"%s\" %u bytes, to offset %u" % (path, len(buf), offset))
 457         size = len(buf)
 458         pre = self.pages[path]['data'][:offset]
 459         post =  self.pages[path]['data'][offset+size:]
 460         data = pre + buf + post
 461         self.pages[path]['size'] = len(data)
 462         log_debug("\"%s\"" % data)
 463         self.pages[path]['data'] = data
 464         self.pages[path]['modified'] = True
 465         return size
 466
 467     def truncate(self, path, size):
 468         log_basic("truncate \"%s\" %u bytes" % (path, size))
 469
 470         if not self.pages.has_key(path):
 471             self.pages[path] = {}
 472         else:
 473             if size > self.pages[path]['size']:
 474                 return -EINVAL
 475         self.pages[path]['modified'] = True
 476         self.pages[path]['size'] = size
 477         if self.pages[path].has_key('data'):
 478             self.pages[path]['data'] = self.pages[path]['data'][size:]
 479         return 0
 480
 481     def release(self, path, flags):
 482         log_basic("release \"%s\"" % path)
 483
 484         ret = self.fsync_do(path)
 485         if ret == 0:
 486             del self.pages[path]['data']
 487
 488         return ret
 489
 490     def fsync(self, path, isfsyncfile):
 491         log_basic("fsync: path=%s, isfsyncfile=%s" % (path, isfsyncfile))
 492         return self.fsync_do(path)
 493
 494     def fsync_do(self, path):
 495         if self.pages.has_key(path):
 496             if self.pages[path]['modified']:
 497                 log_basic("PUT PAGE")
 498                 log_debug("\"%s\"" % self.pages[path]['data'])
 499                 data = unicode(self.pages[path]['data'], out_charset)
 500                 safepath = path.replace("%%","/")
 501                 if self.put2:
 502                     ret = self.wikiproxy.putPage(safepath, data)
 503                 else:
 504                     ret = self.wikiproxy.putPage(safepath, data, {})
 505                 if type(ret) == types.BooleanType and ret == True:
 506                     self.pages[path]['modified'] = False
 507                     return 0
 508                 else:
 509                     log_error("putPage(%s) failed" % path + repr(ret))
 510                     return -EIO
 511
 512 class WikiFS(fuse.Fuse):
 513
 514     def __init__(self, servers, *args, **kw):
 515         fuse.Fuse.__init__(self, *args, **kw)
 516
 517         #log_basic("mountpoint: %s" % repr(self.mountpoint))
 518         #log_basic("unnamed mount options: %s" % self.optlist)
 519         #log_basic("named mount options: %s" % self.optdict)
 520
 521         # do stuff to set up your filesystem here, if you want
 522         #thread.start_new_thread(self.mythread, ())
 523
 524         self.servers = servers
 525
 526     def mythread(self):
 527
 528         """
 529         The beauty of the FUSE python implementation is that with the python interp
 530         running in foreground, you can have threads
 531         """
 532         log_basic("mythread: started")
 533         #while 1:
 534         #    time.sleep(120)
 535         #    log_basic("mythread: ticking")
 536
 537     flags = 1
 538
 539     def getattr(self, path):
 540         log_basic("getattr \"%s\"" % path)
 541
 542         st = MyStat()
 543
 544         st.st_nlink = 2
 545
 546         if path == "/" or (
 547             path.count("/") == 1 and
 548             path[1:] in [server.name for server in self.servers] ):
 549             st.st_mode = S_IFDIR | 0700
 550             return st
 551
 552         server, subname = self.get_subname(path)
 553         if subname:
 554             return server.getattr(subname);
 555
 556         return -EINVAL
 557
 558     def readlink(self, path):
 559         log_basic("readlink")
 560         return -ENOSYS
 561
 562     def readdir_top(self, path, offset):
 563         yield fuse.Direntry('.')
 564         yield fuse.Direntry('..')
 565
 566         for server in self.servers:
 567             yield fuse.Direntry(server.name)
 568
 569     def readdir(self, path, offset):
 570         log_basic("readdir(path='%s', offset=%u)" % (path, offset))
 571
 572         if path == '/':
 573             return self.readdir_top(path, offset)
 574
 575         server_name = path[1:]
 576         for server in self.servers:
 577             if server.name == server_name:
 578                 return server.readdir(offset)
 579
 580         return -EINVAL
 581
 582     def unlink(self, path):
 583         log_basic("unlink")
 584         return -ENOSYS
 585     def rmdir(self, path):
 586         log_basic("rmdir")
 587         return -ENOSYS
 588     def symlink(self, path, path1):
 589         log_basic("symlink")
 590         return -ENOSYS
 591     def rename(self, path, path1):
 592         log_basic("rename")
 593         return -ENOSYS
 594     def link(self, path, path1):
 595         log_basic("link")
 596         return -ENOSYS
 597     def chmod(self, path, mode):
 598         log_basic("chmod")
 599         return -ENOSYS
 600     def chown(self, path, user, group):
 601         log_basic("chown")
 602         return -ENOSYS
 603
 604     def truncate(self, path, size):
 605         log_basic("truncate \"%s\" %u bytes" % (path, size))
 606
 607         server, subname = self.get_subname(path)
 608         if subname:
 609             return server.truncate(subname, size);
 610
 611         return -EINVAL
 612
 613     def mknod(self, path, mode, dev):
 614         log_basic("mknod")
 615         return -ENOSYS
 616     def mkdir(self, path, mode):
 617         log_basic("mkdir")
 618         return -ENOSYS
 619     def utime(self, path, times):
 620         log_basic("utime")
 621         return -ENOSYS
 622
 623     def get_subname(self, path):
 624         for server in self.servers:
 625             prefix = "/" + server.name + "/"
 626             if path.startswith(prefix):
 627                 return (server, path[len(prefix):])
 628
 629         return (None, None)
 630
 631     def open(self, path, flags):
 632         log_basic("open \"%s\" flags %u" % (path, flags))
 633
 634         server, subname = self.get_subname(path)
 635         if subname:
 636             return server.open(subname, flags);
 637
 638         return -EINVAL
 639
 640     #def opendir(self, path):
 641     #    log_basic("opendir \"%s\"" % path)
 642     #    return WikiDir()
 643
 644     def read(self, path, length, offset):
 645         log_basic("read \"%s\" %u bytes, from offset %u" % (path, length, offset))
 646
 647         server, subname = self.get_subname(path)
 648         if subname:
 649             return server.read(subname, length, offset);
 650
 651         return -EINVAL
 652
 653     def write(self, path, buf, offset):
 654         log_basic("write \"%s\" %u bytes, to offset %u" % (path, len(buf), offset))
 655
 656         server, subname = self.get_subname(path)
 657         if subname:
 658             return server.write(subname, buf, offset);
 659
 660         return -EINVAL
 661
 662     def release(self, path, flags):
 663         log_basic("release \"%s\"" % path)
 664
 665         server, subname = self.get_subname(path)
 666         if subname:
 667             return server.release(subname, flags);
 668
 669         return -EINVAL
 670
 671     def fsync(self, path, isfsyncfile):
 672         log_basic("fsync: path=%s, isfsyncfile=%s" % (path, isfsyncfile))
 673
 674         server, subname = self.get_subname(path)
 675         if subname:
 676             return server.fsync(subname, isfsyncfile);
 677
 678         return -EINVAL
 679
 680     def main(self):
 681         fuse.Fuse.main(self)
 682
 683 # Read config file
 684 old_path = sys.path
 685 sys.path = [".",os.environ['HOME'] + "/.config/wikifuse"]
 686 try:
 687     import config
 688 except:
 689     log_error("No configuration file found in '%s'" % sys.path[0])
 690     #log_error(repr(sys.exc_info()[0]))
 691     log_error("Example configuration file (save it as %s/config.py):" % sys.path[0])
 692     log_error(example_config)
 693     sys.exit(1)
 694
 695 sys.path = old_path
 696
 697 def main():
 698     servers = []
 699     for wiki in config.wikis:
 700         proxy = None
 701
 702         if wiki.has_key('use_prefix'):
 703             use_prefix = wiki['use_prefix']
 704         else:
 705             use_prefix = True # default is to follow the spec
 706
 707         if use_prefix:
 708             prefix = "wiki."
 709         else:
 710             prefix = ""
 711
 712         if wiki.has_key('put2'):
 713             put2 = wiki['put2']
 714         else:
 715             put2 = False # default is to follow the spec
 716
 717         if wiki.has_key('auth'):
 718             if wiki['auth'] == 'moin_cookie':
 719                 proxy = WikiServerProxyMoinCookie(wiki['xmlrpc_url'], wiki['user_id'], prefix=prefix)
 720             elif wiki['auth'] == 'moin_auth':
 721                 proxy = WikiServerProxyMoinAuth(wiki['xmlrpc_url'], wiki['username'], wiki['password'], prefix=prefix)
 722             else:
 723                 log_error("Unknown authentication method '%s'" % wiki['auth'])
 724                 continue
 725         else:
 726             proxy = WikiServerProxySimple(wiki['xmlrpc_url'], prefix=prefix)
 727         servers.append(WikiServer(wiki['name'], proxy, put2=put2))
 728
 729     fs = WikiFS(servers,version="%prog " + fuse.__version__,dash_s_do='setsingle')
 730     #fs.multithreaded = 1
 731     fs.parse(errex=1)
 732     fs.main()
 733
 734     for server in servers:
 735         server.cleanup()
 736
 737 if __name__ == '__main__':
 738     main()