root/trunk/dabo/dApp.py

# -*- coding: utf-8 -*-
import sys
import os
import locale
import warnings
import glob
import tempfile
import imp
import ConfigParser
import inspect
import datetime
import urllib2
import shutil
import logging
import dabo
import dabo.ui
import dabo.db
import dabo.dLocalize as dLocalize
import dabo.dException as dException
from dabo.dLocalize import _
from dabo.lib.connParser import importConnections
from dabo import dSecurityManager
from dabo.lib.SimpleCrypt import SimpleCrypt
from dabo.dObject import dObject
from dabo import dUserSettingProvider
from dabo.lib.RemoteConnector import RemoteConnector



class Collection(list):
    """ Collection : Base class for the various collection
    classes used in the app object.
    """
    def __init__(self):
        list.__init__(self)


    def add(self, objRef):
        """Add the object reference to the collection."""
        self.append(objRef)
        

    def remove(self, objRef):
        """Delete the object reference from the collection."""
        try:
            index = self.index(objRef)
        except ValueError:
            index = None
        if index is not None:
            del self[index]



class TempFileHolder(object):
    """Utility class to get temporary file names and to make sure they are 
    deleted when the Python session ends.
    """
    def __init__(self):
        self._tempFiles = []


    def __del__(self):
        self._eraseTempFiles()
        
        
    def _eraseTempFiles(self):
        # Try to erase all temp files created during life.
        # Need to re-import the os module here for some reason.
        try:
            import os
            for f in self._tempFiles:
                if not os.path.exists(f):
                    continue
                try:
                    os.remove(f)
                except OSError, e:
                    if not f.endswith(".pyc"):
                        # Don't worry about the .pyc files, since they may not be there
                        print "Could not delete %s: %s" % (f, e)
        except StandardError, e:
            # In these rare cases, Python has already 'gone away', so just bail
            pass
    
    
    def release(self):
        self._eraseTempFiles()      


    def append(self, f):
        self._tempFiles.append(f)


    def getTempFile(self, ext=None, badChars=None, directory=None):
        if ext is None:
            ext = "py"
        if badChars is None:
            badChars = "-:"
        fname = ""
        suffix = ".%s" % ext
        while not fname:
            if directory is None:
                fd, tmpname = tempfile.mkstemp(suffix=suffix)
            else:
                fd, tmpname = tempfile.mkstemp(suffix=suffix, dir=directory)
            os.close(fd)
            bad = [ch for ch in badChars if ch in os.path.split(tmpname)[1]]
            if not bad:
                fname = tmpname
        self.append(fname)
        if fname.endswith(".py"):
            # Track the .pyc file, too.
            self.append(fname + "c")
        return fname



class dApp(dObject):
    """The containing object for the entire application.

    All Dabo objects have an Application property which refers to the dApp
    instance. Instantiate your dApp object from your main script, like so:

    >>> import dabo
    >>> app = dabo.dApp
    >>> app.start()

    Normally, dApp gets instantiated from the client app's main Python script,
    and lives through the life of the application.

        -- set up an empty data connections object which holds 
        -- connectInfo objects connected to pretty names. If there 
        -- is a file named 'default.cnxml' present, it will import the
        -- connection definitions contained in that. If no file of that
        -- name exists, it will import any .cnxml file it finds. If there
        -- are no such files, it will then revert to the old behavior
        -- of importing a file in the current directory called 
        -- 'dbConnectionDefs.py', which contains connection
        -- definitions in python code format instead of XML.

        -- Set up a DB Connection manager, that is basically a dictionary
        -- of dConnection objects. This allows connections to be shared
        -- application-wide.

        -- decide which ui to use (wx) and gets that ball rolling

        -- look for a MainForm in an expected place, otherwise use default dabo 
        -- dMainForm, and instantiate that. 

        -- maintain a forms collection and provide interfaces for
        -- opening dForms, closing them, and iterating through them.

        -- start the main app event loop.

        -- clean up and exit gracefully

    """
    _call_beforeInit, _call_afterInit, _call_initProperties = False, False, True
    # Behaviors which are normal in the framework may need to
    # be modified when run as the Designer. This flag will 
    # distinguish between the two states.
    isDesigner = False

    
    def __init__(self, selfStart=False, properties=None, *args, **kwargs):
        if dabo.settings.loadUserLocale:
            locale.setlocale(locale.LC_ALL, '')

        self._uiAlreadySet = False
        dabo.dAppRef = self
        self._beforeInit()
        
        # If we are displaying a splash screen, these attributes control
        # its appearance. Extract them before the super call.
        self.showSplashScreen = self._extractKey(kwargs, "showSplashScreen", False)
        basepath = dabo.frameworkPath
        img = os.path.join(basepath, "icons", "daboSplashName.png")
        self.splashImage = self._extractKey(kwargs, "splashImage", img)
        self.splashMaskColor = self._extractKey(kwargs, "splashMaskColor", None)
        self.splashTimeout = self._extractKey(kwargs, "splashTimeout", 5000)
        
        super(dApp, self).__init__(properties, *args, **kwargs)
        # egl: added the option of keeping the main form hidden
        # initially. The default behavior is for it to be shown, as usual.
        self.showMainFormOnStart = True
        self._wasSetup = False
        # Track names of menus whose MRUs need to be persisted. Set
        # the key for each entry to the menu caption, and the value to
        # the bound function.
        self._persistentMRUs = {}
        # Create the temp file handlers.
        self._tempFileHolder = TempFileHolder()
        self.getTempFile = self._tempFileHolder.getTempFile
        # Create the framework-level preference manager
        self._frameworkPrefs = dabo.dPref(key="dabo_framework")
        # Hold a reference to the bizobj and connection, if any, controlling 
        # the current database transaction
        self._transactionTokens = {}
        # Holds update check times in case of errors.
        self._lastCheckInfo = []
        # Location and Name of the project; used for Web Update
        self._projectInfo = (None, None)
        self._setProjInfo()
        # Other Web Update values
        self.projectAbbrevs = {"dabo": "frm",
                "class designer": "cds",
                "cxn editor": "cxe",
                "editor": "edt",
                "menu designer": "mds",
                "preference editor": "prf",
                "report designer": "rds",
                "wizards": "wiz",
                "dabodemo": "dem"}
        self.webUpdateDirs = {"dabo": "dabo",
                "class designer": "ide",
                "cxn editor": "ide",
                "editor": "ide",
                "menu designer": "ide",
                "preference editor": "ide",
                "report designer": "ide",
                "wizards": "ide",
                "dabodemo": "demo"}

        # List of form classes to open on App Startup
        self.formsToOpen = []  
        # Form to open if no forms were passed as a parameter
        self.default_form = None
        # Dict of "Last-Modified" values for dynamic web resources
        self._sourceLastModified = {}
        
        # For simple UI apps, this allows the app object to be created
        # and started in one step. It also suppresses the display of
        # the main form.
        if selfStart:
            self.showMainFormOnStart = False
            self.setup()

        self._initDB()

        # If running as a web app, sync the files
        rp = self._RemoteProxy
        if rp:
            try:
                rp.syncFiles()
            except urllib2.URLError, e:
                code, msg = e.reason
                if code == 61:
                    # Connection refused; server's down
                    print _("""


The connection was refused by the server. Most likely this means that
the server is not running. Please have that problem corrected, and
try again when it is running.

""")
                    sys.exit(61)

        self._afterInit()
        self.autoBindEvents()
        

    def __del__(self):
        """Make sure that temp files are removed"""
        self._tempFileHolder.release()
        

    def setup(self, initUI=True):
        """Set up the application object."""
        # dabo is going to want to import various things from the Home Directory
        if self.HomeDirectory not in sys.path:
            sys.path.append(self.HomeDirectory)
        
        def initAppInfo(item, default):
            if not self.getAppInfo(item):
                self.setAppInfo(item, default)

        initAppInfo("appName", "Dabo Application")
        initAppInfo("appShortName", self.getAppInfo("appName").replace(" ", ""))
        initAppInfo("appVersion", "")
        initAppInfo("vendorName", "")

        # If there's a locale directory for the app and it looks valid, install it:
        localeDir = os.path.join(self.HomeDirectory, "locale")
        localeDomain = self.getAppInfo("appShortName").replace(" ", "_").lower()
        if os.path.isdir(localeDir) and dLocalize.isValidDomain(localeDomain, localeDir):
            lang = getattr(self, "_language", None)
            charset = getattr(self, "_charset", None)
            dLocalize.install(localeDomain, localeDir)
            dLocalize.setLanguage(lang, charset)

        self._initModuleNames()
        self._initDB()

        if initUI:
            self._initUI()
            if self.UI is not None:
                if self.showSplashScreen:
                    #self.uiApp = dabo.ui.uiApp(self, callback=self.initUIApp)
                    self.uiApp = dabo.ui.getUiApp(self, callback=self.initUIApp)
                else:
                    #self.uiApp = dabo.ui.uiApp(self, callback=None)
                    self.uiApp = dabo.ui.getUiApp(self, callback=None)
                    self.initUIApp()
        else:
            self.uiApp = None
        # Flip the flag
        self._wasSetup = True
        # Call the afterSetup hook
        self.afterSetup()


    def afterSetup(self):
        """Hook method that is called after the app's setup code has run, and the
        database, UI and module references have all been established.
        """
        pass


    def startupForms(self):
        """Open one or more of the defined forms. The default one is specified 
        in .default_form. If form names were passed on the command line, 
        they will be opened instead of the default one as long as they exist.
        """
        form_names = [class_name[3:] for class_name in dir(self.ui) if class_name[:3] == "Frm"]
        for arg in sys.argv[1:]:
            arg = arg.lower()
            for form_name in form_names:
                if arg == form_name.lower():
                    self.formsToOpen.append(getattr(self.ui, "Frm%s" % form_name))
        if not self.formsToOpen:
            self.formsToOpen.append(self.default_form)
        for frm in self.formsToOpen:
            frm(self.MainForm).show()

    def initUIApp(self):
        """Callback from the initial app setup. Used to allow the 
        splash screen, if any, to be shown quickly.
        """
        self.uiApp.setup()


    def start(self):
        """Start the application event loop."""
        if not self._wasSetup:
            # Convenience; if you don't need to customize setup(), just
            # call start()
            self.setup()

        self._finished = False
        if (not self.SecurityManager or not self.SecurityManager.RequireAppLogin
            or self.SecurityManager.login()):
            
            userName = self.getUserCaption()
            if userName:
                userName = " (%s)" % userName
            else:
                userName = ""
            
            self._retrieveMRUs()
            self.uiApp.start(self)
        if not self._finished:
            self.finish()
    
    
    def finish(self):
        """Called when the application event loop has ended. You may also 
        call this explicitly to exit the application event loop.
        """
        self.uiApp.exit()
        self._persistMRU()
        self.uiApp.finish()
        self.closeConnections()
        self._tempFileHolder.release()
        dabo.infoLog.write(_("Application finished."))
        self._finished = True
        self.afterFinish()


    def afterFinish(self):
        """Stub method. When this is called, the app has already terminated, and you have 
        one last chance to execute code by overriding this method.
        """
        pass


    def _setProjInfo(self):
        """Create a 2-tuple containing the project location and project name, if any. 
        The location is always the directory containing the initial startup program; the
        name is either None (default), or, if this is a Web Update-able app, the 
        descriptive name.
        """
        relpth = inspect.stack()[-1][1]
        op = os.path
        pth, fnm = op.split(op.normpath(op.join(os.getcwd(), relpth)))
        projnames = {"ClassDesigner.py": "Class Designer",
                "CxnEditor.py": "Cxn Editor",
                "Editor.py": "Editor",
                "MenuDesigner.py": "Menu Designer",
                "PrefEditor.py": "Preference Editor",
                "ReportDesigner.py": "Report Designer",
                "DaboDemo.py": "DaboDemo"}
        nm = projnames.get(fnm, None)
        if nm is None:
            if "wizards" in pth:
                nm ="Wizards"
        self._projectInfo = (pth, nm)
        
        
    def getLoginInfo(self, message=None):
        """Return a tuple of (user, password) to dSecurityManager.login(). The default is to display the standard login dialog, and return the user/password as entered by the user, but subclasses can override to get the information from whereever is appropriate. You can customize the default dialog by adding your own code to the loginDialogHook() method, which will receive a reference to the login dialog.

        Return a tuple of (user, pass).
        """
        import dabo.ui.dialogs.login as login
        ld = login.Login(self.MainForm)
        ld.setMessage(message)
        # Allow the developer to customize the default login
        self.loginDialogHook(ld)
        ld.show()
        user, password = ld.user, ld.password
        return user, password
    
    
    def loginDialogHook(self, dlg):
        """Hook method; modify the dialog as needed."""
        pass
    
    
    def _persistMRU(self):
        """Persist any MRU lists to disk."""
        base = "MRU.%s" % self.getAppInfo("appName")
        self.deleteAllUserSettings(base)        
        for cap in self._persistentMRUs.keys():
            mruList = self.uiApp.getMRUListForMenu(cap)
            setName = ".".join((base, cap))
            self.setUserSetting(setName, mruList)
    
    
    def _retrieveMRUs(self):
        """Retrieve any saved MRU lists."""
        base = "MRU.%s" % self.getAppInfo("appName")
        for cap, fcn in self._persistentMRUs.items():
            itms = self.getUserSetting(".".join((base, cap)))
            if itms:
                # Should be a list of items. Add 'em in reverse order
                for itm in itms:
                    self.uiApp.addToMRU(cap, itm, fcn)
        

    def getAppInfo(self, item):
        """Look up the item, and return the value."""
        try:
            retVal = self._appInfo[item]
        except KeyError:
            retVal = None
        return retVal


    def setAppInfo(self, item, value):
        """Set item to value in the appinfo table."""
        self._appInfo[item] = value


    def _currentUpdateVersion(self, proj):
        if proj == "Dabo":
            localVers = dabo.version["file_revision"]
            try:
                localVers = localVers.split(":")[1]
            except IndexError:
                # Not a mixed version
                pass
            ret = int("".join([ch for ch in localVers if ch.isdigit()]))
        else:
            ret = self.PreferenceManager.getValue("current_version")
            if ret is None:
                ret = 0         
        return ret

    
    def _resetWebUpdateCheck(self):
        """Sets the time that Web Update was last checked to the passed value. Used
        in cases where errors prevent an update from succeeding.
        """
        for setter, val in self._lastCheckInfo:
            setter("last_check", val)


    def checkForUpdates(self, evt=None):
        """Public interface to the web updates mechanism. Returns a 2-tuple
        consisting of a boolean and a list of projects available for update. The boolean 
        indicates whether this is the first time that the framework is being run and the list
        contains the updatable project names; e.g., if both project 'Foo' and the framework
        have updates, it will return ["Dabo", "Foo"]; if only the framework has updates, it will
        return ["Dabo"]. If there are no updates available, an empty list will be returned.
        """
        return self.uiApp.checkForUpdates(force=True)


    def _checkForUpdates(self, force=False):
        """This is the actual code that checks if a) we are using Web Update; b) if we are
        due for a check; and then c) returns the status of the available updates, if any.
        """
        frameloc = dabo.frameworkPath
        pth, projectName = self._projectInfo
        if not force:
            # Check for cases where we absolutely will not Web Update.
            update = dabo.settings.checkForWebUpdates
            if update:
                # If they are running Subversion, don't update.
                if pth is None:
                    pth = frameloc
                if os.path.isdir(os.path.join(pth, ".svn")):
                    update = False
                # Frozen App:
                if hasattr(sys, "frozen") and inspect.stack()[-1][1] != "daborun.py":
                    update = False

            if not update:
                self._setWebUpdate(False)
                return (False, [])

        # First check the framework. If it has updates available, return that info. If not,
        # see if this is an updatable project. If so, check if it has updates available, and
        # return that info.
        prefs = [("Dabo", self._frameworkPrefs)]
        if projectName is not None:
            prefs.insert(0, (projectName, self.PreferenceManager))
        retFirstTime = False
        retUpdateNames = []
        self._lastCheckInfo = []
        for nm, prf in prefs:
            val = prf.getValue
            abbrev = self.projectAbbrevs.get(nm.lower())
            retFirstTime = (nm == "Dabo") and not prf.hasKey("web_update")
            retAvailable = False
            lastcheck = val("last_check")
            # Store the pref setter and the time so that we can reset the value
            # in case the update fails later.
            self._lastCheckInfo.append((prf.setValue, lastcheck))
            if not retFirstTime:
                runCheck = force
                now = datetime.datetime.now()
                if not force:
                    webUpdate = val("web_update")
                    if webUpdate:
                        checkInterval = val("update_interval")
                        if checkInterval is None:
                            # Default to one day
                            checkInterval = 24 * 60
                        mins = datetime.timedelta(minutes=checkInterval)
                        if lastcheck is None:
                            lastcheck = datetime.datetime(1900, 1, 1)
                        runCheck = (now > (lastcheck + mins))
                if runCheck:
                    # See if there is a later version
                    url = "http://dabodev.com/frameworkVersions/latest?project=%s" % abbrev
                    try:
                        vers = int(urllib2.urlopen(url).read())
                    except ValueError:
                        vers = -1
                    except StandardError, e:
                        dabo.errorLog.write(_("Failed to open URL '%(url)s'. Error: %(e)s") % locals())
                    localVers = self._currentUpdateVersion(nm)
                    retAvailable = (localVers < vers)
                prf.setValue("last_check", now)
                if retFirstTime or retAvailable:
                    retUpdateNames.append(nm)
        return (retFirstTime, retUpdateNames)


    def _updateFramework(self, projNames=None):
        """Get any changed files from the dabodev.com server, and replace 
        the local copies with them. Return the new revision number"""
        fileurl = "http://dabodev.com/frameworkVersions/changedFiles/%s/%s"
        for pn in projNames:
            currvers = self._currentUpdateVersion(pn)
            if pn == "Dabo":
                localBasePath = dabo.frameworkPath
            else:
                localBasePath = self._projectInfo[0]
            abbrev = self.projectAbbrevs[pn.lower()]
            webpath = self.webUpdateDirs[pn.lower()]
            try:
                resp = urllib2.urlopen(fileurl % (