# # $Id: Application.py,v 1.6 1999/12/16 10:00:32 rob Exp $ # # Copyright 1999 Rob Tillotson # All Rights Reserved # # Permission to use, copy, modify, and distribute this software and # its documentation for any purpose and without fee or royalty is # hereby granted, provided that the above copyright notice appear in # all copies and that both the copyright notice and this permission # notice appear in supporting documentation or portions thereof, # including modifications, that you you make. # # THE AUTHOR ROB TILLOTSON DISCLAIMS ALL WARRANTIES WITH REGARD TO # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY # AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY # SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER # RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF # CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE! # """Pyrite Application Subclass """ __version__ = '$Id: Application.py,v 1.6 1999/12/16 10:00:32 rob Exp $' __copyright__ = 'Copyright 1999 Rob Tillotson ' from types import ClassType from whrandom import randint import os, operator, string, time import urlparse, urllib if 'user' not in urlparse.uses_netloc: urlparse.uses_netloc.append('user') from Pyrite import Plugin from Pyrite.Store import Directory import Sulfur from Sulfur import Registry, Options, AppContext from Sulfur import misc import Sulfur.Application import Pyrite from Pyrite import protect_name, unprotect_name, Database, _ # try: import cPickle pickle = cPickle except: import pickle # def _mkdir(d): if os.path.exists(d): if not os.path.isdir(d): raise RuntimeError, _("%s exists, but is not a directory") % d else: os.mkdir(d) #def find_user_directory(dd, u, id=None): # if id: # d = os.path.join(dd, protect_name('%s.%s' % (u, id))) # try: # os.stat(d) # return d # except os.error: # pass # # d = os.path.join(dd, protect_name(u)) # try: # os.stat(d) # return d # except os.error: # return None #def user_directory_name(data_directory, user, uid=None): # if uid is not None: # d = os.path.join(data_directory, protect_name('%s.%s' % (user, uid))) # else: # d = os.path.join(data_directory, protect_name(str(user))) # return d class Application(Sulfur.Application.Application): """A Pyrite application. """ type = 'PyriteApplication' name = 'DefaultApplication' app_prefix = 'Pyrite' options = [ Options.Boolean('old-pdb', 0, _("use old prc/pdb access code"), None, (), ['old-pdb']), Options.Boolean('old-dlp', 0, _("use old DLP access code"), None, (), ['old-dlp']), Options.Boolean('debug', 0, _("enable debugging code"), None, (), ['debug']), ] def __init__(self): Sulfur.Application.Application.__init__(self) self.port = None self.default_user = None self.default_uid = None self.user = None self.uid = None self.sync_id = None self.remote = None self.state = {} self.plugin_module_path.insert(0, 'Pyrite') def prerun(self): r = self.registry # r = Registry.Registry() # self.registry = r # r.load('/etc/palm.conf', 'SYSTEM') # r.load(os.path.expanduser('~/.palm.conf'), 'USER') # Pyrite default plugin path # pp = r.get('Pyrite::plugin-packages',[]) # if type(pp) != type([]): pp = [ pp ] # for p in pp: self.plugin_module_path.append(p) ## FIXME do something intelligent with ports # first, we try environment variables. if os.environ.has_key('PYRITEPORT'): self.port = os.environ['PYRITEPORT'] elif os.environ.has_key('PILOTPORT'): self.port = os.environ['PILOTPORT'] else: # select default port if r.has_key('defaults::default-port'): self.port = r.get('defaults::default-port') if type(self.port) == type([]): if self.port: self.error(_("defaults::default-port option should not be a list."),'warning') self.error(_("using %s as the default port.") % self.port[0], 'warning') self.port = self.port[0] else: self.error(_("defaults::default-port is an empty list."),'warning') self.port = None else: p = r.get('defaults::port','') if type(p) == type([]): if p: self.port = p[0] else: self.error(_("defaults::port is an empty list."),'warning') self.port = None else: # backward compatibility if ',' in p: self.port = string.strip(string.split(p, ',')[0]) else: self.port = p if not self.port: self.error(_("no port specified in config file, using /dev/pilot"),'warning') self.port = '/dev/pilot' if os.environ.has_key('PYRITEPATH'): self.data_directory = os.environ['PYRITEPATH'] else: self.data_directory = os.path.expanduser(r.get('defaults::data-directory','')) if not self.data_directory: self.error(_("no data directory specified, using ~/Palm"),'warning') self.data_directory = os.path.expanduser('~/Palm') _mkdir(self.data_directory) pydir = os.path.join(self.data_directory, 'Pyrite') _mkdir(pydir) # get saved state try: self.state = pickle.load(open(os.path.join(pydir,'state'),'r')) except: self.state = {} # if the user and uid are specified in the conf file, # we use them. otherwise, use the ones in the state. if os.environ.has_key('PYRITEUSER'): self.default_user = os.environ['PYRITEUSER'] else: self.default_user = r.get('defaults::user',self.state.get('user',None)) if os.environ.has_key('PYRITEUID'): self.default_uid = os.environ['PYRITEUID'] else: self.default_uid = r.get('defaults::uid',self.state.get('uid',None)) # some defaults if not self.default_uid: self.error(_("no default user specified"),'warning') if self.default_uid and self.default_user and not self.user_exists(self.default_uid): self.user_add(self.default_uid, self.default_user) # make a new PC ID if there isn't one already, or if the state file was # written with a different version of Pyrite. (This makes sure to do # a slow sync in case there have been any changes to Pyrite which might # affect the fast sync logic or database contents etc.) if not self.state.has_key('syncid') or \ not self.state.has_key('pyrite_version') or \ (self.state['pyrite_version'] != Pyrite.version): from whrandom import randint self.state['syncid'] = (randint(0, 65535) << 16 | randint(0, 65535)) self.sync_id = self.state.get('syncid',0) # add products if self.state.has_key('products'): prd = {} for pkg in self.state['products'].values(): # in the future, we will need to import all packages here, # to check for callbacks. if pkg and pkg not in self.plugin_module_path: self.plugin_module_path.append(pkg) self.change_user(self.default_uid) def postrun(self): self.state['user'] = self.user self.state['uid'] = self.uid self.state['syncid'] = self.sync_id self.state['pyrite_version'] = Pyrite.version if self.data_directory: _mkdir(self.data_directory) _mkdir(os.path.join(self.data_directory, 'Pyrite')) try: pickle.dump(self.state, open(os.path.join(self.data_directory,'Pyrite', 'state'),'w')) except: pass if self.connected(): self.disconnect() # def configure_user(self): # if not self.user: return # if self.registry.label() == 'PALMUSER': # self.registry.pop() # # if not self.user_exists(self.user, self.uid): # self.error(_("palmtop user '%s' does not have a directory; creating one")) # self.user_add(self.user) # # try: # d = find_user_directory(self.data_directory, self.user, self.uid) # except: # self.error(_("user '%s' might not exist") % self.user, 'error') # return # # if d is None: # self.error(_("user directory for '%s' not found") % self.user, 'error') # return # # self.registry.load(os.path.join(d, 'palm.conf'), 'PALMUSER') # self.configure(self.registry) # # for p in self.plugins.values(): # p.configure(self.registry) # ---------------------------------------------------------------- # Connection Stuff # # Instantiating a DLP Store does not actually connect to the device; # connection is deferred until the application actually does something # with the Store, at which point the preconnect and postconnect # functions are called at the appropriate time. # ---------------------------------------------------------------- def preconnect(self, *a, **kw): print _("Waiting for connection on %s (start the HotSync(R) application now)...") % self.port def postconnect(self, store, *a, **kw): self.log(_("Identifying user...")) uinfo = store.user_info self.log(_("User Name: %s") % uinfo['name']) self.log(_("Last Sync: %s") % time.ctime(uinfo['lastSyncDate'])) self.log(_("Last Successful Sync: %s") % time.ctime(uinfo['successfulSyncDate'])) self.log(_("UID: %s VID: %s LastSyncPC: 0x%08x") % (uinfo['userID'], uinfo['viewerID'], uinfo['lastSyncPC'])) self.connect_user() def connect(self, immediate=0): """Instantiate a remote store.""" if self.get_option('old-dlp'): p = self.get_plugin('Store','OldDLP') else: p = self.get_plugin('Store','DLP') self.remote = p(self.port, 0, self.preconnect, self.postconnect) if immediate: self.remote.connect() return self.remote def disconnect(self, successful=1, log=_("Sync completed.")): self.remote.disconnect(successful, log) def connected(self): return self.remote is not None and self.remote.connected() # get something from the registry # get an appmodule # spool something for later install def user_path(self, name=None, uid=None): if uid is None: uid = self.uid if not self.uid: raise RuntimeError, _("uid is zero") if name: return os.path.join(self.data_directory, str(uid), name) else: return os.path.join(self.data_directory, str(uid)) def user_directory(self, dir='backup', make=1, uid=None): """Access a specific user data directory. Returns an appropriate Directory Store object. If the 'make' parameter is true (the default), and the directory doesn't exist, it will be created. """ if uid is None: uid = self.uid if not uid: raise RuntimeError, _("uid is zero") path = os.path.join(self.data_directory, str(uid), dir) if make: _mkdir(path) if self.get_option('old-pdb'): p = self.get_plugin('Store','OldDirectory') else: p = self.get_plugin('Store','Directory') s = p(path) return s # issue: expand to handle deeper levels? # do we even need this function? def user_directories(self): """List all available top-level user directories. """ p = os.path.join(self.data_directory, str(self.uid)) return filter(lambda x, path=p: os.path.isdir(os.path.join(path, x)), os.listdir(p)) def open(self, name, mode='rs', dbclass=Database, **kw): """Open an arbitrary database. This function can take either a filename or a URL as its argument. The following URL types are acceptable: http -- database is fetched and opened read-only ftp -- database is fetched and opened read-only file -- equivalent to filename if on 'localhost', otherwise tries ftp user -- open a database in a user directory: user://username/directory/databasename If attempting to open by filename fails, this function then tries to open by *database name* in the current directory. """ scheme, loc, path, param, query, frag = urlparse.urlparse(name) if scheme == 'user': user = urllib.unquote(loc) path, n = os.path.split(path) if path and path[0] == '/': path = path[1:] if not user: user = self.user if not path: path = 'backup' # avoid unnecessary making of directories if 'w' in mode: make = 1 else: make = 0 try: u = int(user) except: u = self.user_lookup(user) if not u: raise RuntimeError, _("user '%s' not found") % user s = self.user_directory(path, make, u) return apply(s.open, (n,mode,dbclass), kw) elif scheme in ['http','ftp'] or \ (scheme == 'file' and loc and loc != 'localhost'): p = self.get_plugin('Store','URL') s = p(name) l = s.list() # this actually fetches the file, it is now cached return apply(s.open, (name,mode,dbclass), kw) else: if scheme == 'file': name = path if self.get_option('old-pdb'): p = self.get_plugin('Store','OldFile') else: p = self.get_plugin('Store','File') s = p(name) l = s.list() # if this isn't a valid filename, try opening it as a # database name instead. if not l: path, n = os.path.split(name) if self.get_option('old-pdb'): p = self.get_plugin('Store','OldDirectory') else: p = self.get_plugin('Store','Directory') s = p(path) name = n return apply(s.open, (name,mode,dbclass), kw) # -------------------------------------- # User Management # -------------------------------------- # def user_exists(self, user, uid=None): # return find_user_directory(self.data_directory, user, uid) is not None # # def user_add(self, user, uid=None): # d = user_directory_name(self.data_directory, user, uid) # _mkdir(d) # _mkdir(os.path.join(d, 'backup')) # _mkdir(os.path.join(d, 'install')) # # def user_delete(self, user, uid=None): # import shutil # d = find_user_directory(self.data_directory, user, uid) # if d: # shutil.rmtree(d, 1) # # def user_rename(self, user, newuser, uid=None, newuid=None): # d = find_user_directory(self.data_directory, user, uid) # n = user_directory_name(self.data_directory, newuser, newuid) # os.rename(d, n) # # def user_list(self): # l = [] # d = os.getcwd() # os.chdir(self.data_directory) # for dir in filter(os.path.isdir, os.listdir('.')): # os.chdir(os.path.join(self.data_directory, dir)) # # simple rule to determine if this is probably a known user # if os.path.isdir('backup') and os.path.isdir('install'): # l.append(unprotect_name(dir)) # os.chdir(d) # l.sort() # return l # user management, take two # note: assumes self.remote is connected already def connect_user(self): user = self.remote.user_info['name'] uid = self.remote.user_info['userID'] rewrite = 0 if not user and not uid: self.error(_("Pyrite does not support unidentified palmtops (yet)")) return if not uid: uid = (randint(0, 65535) << 16 | randint(0, 65535)) self.error(_("Palm user ID is zero. Assigning a new one (%d).") % uid, 'warning') rewrite = 1 if not self.user_exists(uid): self.user_add(uid, user) un = user else: un = self.user_name(uid) if user != un: self.error(_("Palm user name does not match. Restoring."), 'warning') self.error(_("'%s' / '%s'") % (user, un)) user = un self.remote.user_info['name'] = un self.change_user(uid) # change users. note that the user has to exist! def change_user(self, uid): if self.registry.label() == 'PALMUSER': self.registry.pop() if not uid: return if not self.user_exists(uid): raise RuntimeError, _("user #%d is unknown") % uid self.uid = uid self.user = self.user_name(uid) self.registry.load(os.path.join(self.data_directory, str(uid), 'Pyrite', 'palm.conf'), 'PALMUSER') for p in self.plugins.values(): p.configure(self.registry) def user_add(self, uid, user): ud = os.path.join(self.data_directory, str(uid)) # set up pyrite for a new user _mkdir(ud) _mkdir(os.path.join(ud, 'backup')) _mkdir(os.path.join(ud, 'install')) _mkdir(os.path.join(ud, 'Pyrite')) if not user: self.error(_("This palmtop has an empty user name."), 'warning') user = '' # just in case it's None open(os.path.join(ud, 'NAME'), 'w').write(user) def user_name(self, uid): try: s = open(os.path.join(self.data_directory, str(uid), 'NAME')).readline() if s[-1] == '\n': return s[:-1] else: return s except: return '' def user_exists(self, uid): return os.path.isdir(os.path.join(self.data_directory, str(uid))) def user_list(self): l = [] _d = os.getcwd() os.chdir(self.data_directory) for dir in filter(os.path.isdir, os.listdir('.')): try: id = int(dir) # will throw exception if not a numeric dir name l.append(id) except: continue os.chdir(_d) l.sort() return l def user_lookup(self, name): for i in self.user_list(): if self.user_name(i) == name: return i return 0 # --------------------------- # Application Data Management # --------------------------- def app_path(self, path=None): p = os.path.join(self.data_directory, self.app_prefix) _mkdir(p) if path: p = os.path.join(p, path) return p def app_user_path(self, path=None, uid=None): if uid is None: uid = self.uid if not uid: raise RuntimeError, _("uid is zero") p = os.path.join(self.data_directory, str(uid), self.app_prefix) _mkdir(p) if path: p = os.path.join(p, path) return p def user_open(self, name, mode='r', uid=None): p = self.user_path(name, uid) return open(p, mode) def app_open(self, name, mode='r'): p = self.app_path(name) return open(p, mode) def app_user_open(self, name, mode='r', uid=None): p = self.app_user_path(name, uid) return open(p, mode) # # products: a product is a Pyrite add-on which provides plug-ins. # # it is assumed to already be locatable on the Python path, and # # these functions merely allow Pyrite to be aware that it exists # # so that it can add all products to its search path # # automatically. # def product_install(self, package): # if not self.state.has_key('products'): # self.state['products'] = {} # try: # m = misc.import_module(package) # except: # m = None # if not m: # raise ImportError, _("Could not import package '%s'") % package # if not hasattr(m, 'PYRITE_PRODUCT'): # raise RuntimeError, _("Package '%s' does not appear to contain a Pyrite product.") % package # name = m.PYRITE_PRODUCT['name'] # if package not in self.plugin_module_path: # self.plugin_module_path.append(package) # self.state['products'][name] = package # return name # def product_list(self): # if not self.state.has_key('products'): # self.state['products'] = {} # l = [] # for name, pkg in self.state['products'].items(): # try: # m = misc.import_module(pkg) # except: # continue # if not hasattr(m, 'PYRITE_PRODUCT'): # continue # q = {'package': pkg, # 'name': m.PYRITE_PRODUCT.get('name'), # 'author': m.PYRITE_PRODUCT.get('author'), # 'version': m.PYRITE_PRODUCT.get('version'), # 'description': m.PYRITE_PRODUCT.get('description') # } # l.append(q) # l.sort(lambda x,y: cmp(x.get('name'),y.get('name'))) # return l # def product_remove(self, name): # if not self.state.has_key('products'): # self.state['products'] = {} # if self.state['products'].has_key(name): # p = self.state['products'][name] # if p and p in self.plugin_module_path: # self.plugin_module_path.remove(p) # del self.state['products'][name] # def product_installed(self, name): # return self.state['products'].has_key(name) # def product_info(self, name): # for p in self.product_list(): # if p['name'] == name: return p # return {} # Backward compatibility (temporary overrides) def get_plugin(self, collection, name, *a, **kw): if collection == 'App': self.error(_("using deprecated name for application modules; should be 'Connector', not 'App'"), 'warning') collection = 'Connector' return apply(Sulfur.Application.Application.get_plugin, (self, collection, name)+a, kw) def __call__(self, *a, **kw): ctx = PyriteCLIAppContext(self) apply(ctx, a, kw) class PyriteState(AppContext.PickleState): def start(self, context): AppContext.PickleState.start(self, context) context.registry.load('/etc/palm.conf', 'SYSTEM') context.registry.load(os.path.expanduser('~/.palm.conf'), 'USER') class PyriteCLIAppContext(AppContext.CLIAppContext): app_type = 'Pyrite' def __init__(self, *a, **kw): apply(AppContext.CLIAppContext.__init__, (self,)+a, kw) self.state_manager = PyriteState()