version.py

import json, logging, re, time, urllib, zipfile
try:
    import tarfile
except:
    tarfile = None
import os, sys, shutil
try:
    from pnc.attrdict import AttrDict
except ImportError:
    # Fall back on the old location - just in case
    from pnc.dep.attrdict import AttrDict

logger = logging.getLogger(__name__)

USER_TYPE = "user"
                  # user - for normal people
                  # beta - for the original beta testers
                  # dev  - used to be for git users, now it's anyone with the 3.41 beta
                  # edge - new git stuff. bleeding edge, do not try at home (kiooeht version)

INSTALL_TYPE = "installer"
                  # installer - Windows/Mac installer     (exe/dmg)
                  # zip       - Windows zip               (zip)
                  # source    - Win/Linux/Mac source code (zip/tar)

OS_TYPE = sys.platform # win32, linux, darwin
if OS_TYPE.startswith("linux"):
    OS_TYPE = "linux"
elif OS_TYPE == "darwin":
    OS_TYPE = "mac"

# These will eventually be phased out
_pcMajor = "3.41"
_pcMinor = "4"
_pcStatus = "A" # A  = alpha
                # B  = beta
                # RC = release candidate
                # None = public release
_pcRevision = "13"
_pcVersion = ""

_updateCheckURL = "https://github.com/karxi/pesterchum/raw/master/VERSION.js"
_downloadURL = "https://github.com/karxi/pesterchum/archive/master.zip"

jsodeco = json.JSONDecoder()

# Whether or not we've completed an update (requires a restart).
has_updated = False

def _py_version_check():
    import sys
    # == Python Version Checking ==
    # Check that we're running the right version of Python.
    # This is the version we need.
    pyreq = {"major": 2, "minor": 7}

    # Just some preprocessing to make formatting the version info a little
    # easier. Note that the sys.version_info type doesn't convert to dict,
    # despite having named indices like a namedtuple, so we have to do it
    # manually.
    # This is the version we have.
    pyver = dict(zip(("major", "minor"), sys.version_info[:2]))

    # Compose the base of an error message that we may use in the future.
    errmsg = "ERROR: Pesterchum is designed to be run on Python " + \
             "{major}.{minor}.".format(**pyreq)
    errmsg = [ errmsg ]
    errmsg.append("It is not designed for use with Python {major}.{minor}.")
    # Now we have a list that we can further process into a more specific
    # error message.
    if pyver["major"] > pyreq["major"]:
        # We're using Python 3, which this script won't work with.
        errmsg = errmsg.extend([
                "Due to syntax differences,",
                "it cannot be run with this version of Python."
                ])
        errmsg = ' '.join(errmsg)
        errmsg = errmsg.format(**pyver)
        logger.critical(errmsg)
        sys.exit()
    elif pyver["major"] != pyreq["major"] or pyver["minor"] < pyreq["minor"]:
        # We're either not running Python 2 (we have something earlier?!) or
        # we're below the minimum required minor version (e.g. 2.6 or 2.4 or
        # similar).
        # This means that we wouldn't have certain syntax improvements that we
        # need - like inline generators, 'with' statements, lambdas, etc.
        # NOTE: This MAY be lowered to 2.6 later, since there's little
        # difference.
        errmsg = errmsg.extend([
                "This version of Python lacks certain features",
                "that are necessary for it to run."
                ])
        errmsg = ' '.join(errmsg)
        errmsg = errmsg.format(**pyver)
        logger.critical(errmsg)
        sys.exit()

# Not 100% finished - certain output formats seem odd
def get_pchum_ver(raw=0, pretty=False, file=None, use_hard_coded=None):
    # If use_hard_coded is None, we don't care. If it's False, we won't use it.
    getrawlines = lambda fobj: [ x.strip() for x in fobj.readlines() ]
    if file:
        # Don't fall back onto defaults if we were given a file.
        use_hard_coded = False

    try:
        if use_hard_coded:
            # This is messy code, but we just want it to work for now.
            raise ValueError

        if file:
            # Leave closing this to the caller.
            raw_ver = getrawlines(file)
        else:
            # Open our default file ourselves.
            with open("VERSION.js", 'r') as fo:
                raw_ver = getrawlines(fo)
        raw_ver = ' '.join(raw_ver)
        # Now that we have the actual version, we can just set everything up
        # neatly.
        ver = jsodeco.decode(raw_ver)
        ver = AttrDict( (k.encode('ascii'), v) for k, v in ver.items() )
        # Do a bit of compensation for the unicode part of JSON.
        ver.status, ver.utype = str(ver.status), str(ver.utype)
    except:
        if use_hard_coded == False:
            # We refuse to use the hard-coded values, period.
            raise

        global _pcMajor, _pcMinor, _pcStatus, _pcRevision, USER_TYPE
        ver = AttrDict({
            "major": _pcMajor, "minor": _pcMinor,
            "status": _pcStatus, "rev": _pcRevision,
            "utype": USER_TYPE
            })

    ver.major = float(ver.major)
    ver.minor = int(ver.minor)
    if not ver.status:
        ver.status = None
    ver.rev = int(ver.rev)
    if raw:
        if raw > 1:
            # Give the AttrDict.
            return ver
        else:
            # Give a tuple.
            return (ver.major, ver.minor, ver.status, ver.rev, ver.utype)
    # Compose the version information into a string.
    # We usually specify the format for this pretty strictly.
    # We wnat it to look like "3.14.01-A07", for example.
    elif pretty:
        if pretty > True:
            # True == 1; we get here if pretty is greater than 1
            if ver.utype == "edge":
                # If this is an edge build, the other types don't really
                # matter.
                ver.status = "Bleeding Edge"
            else:
                statuses = {
                        # These are slightly unnecessary, but....
                        "A":    "Alpha",
                        "B":    "Beta",
                        "RC":   "Release Candidate"
                        }
                # Pick a status or don't give one.
                ver.status = statuses.get(ver.status, "")
            if ver.status:
                ver.status = " " + ver.status
            # Not the same as the original output, but it seems nicer.
            retval = "{major:.2f}.{minor:02d}{status!s} {rev:02d}"
        else:
            retval = "{major:.2f}.{minor:02d}-r{rev:02d}{status!s} ({utype!s})"
    elif ver.status:
        retval = "{major:.2f}.{minor:02d}-{status!s}{rev:02d}"
    else:
        retval = "{major:.2f}.{minor:02d}.{rev:02d}"
    return retval.format(**ver)

def pcVerCalc():
    global _pcVersion

    # The logic for this has been moved for the sake of ease of use.
    _pcVersion = get_pchum_ver(raw=False)


def lexVersion(short=False):
    if not _pcStatus:
        return "%s.%s" % (_pcMajor, _pcMinor)

    utype = ""
    if USER_TYPE == "edge":
        utype = "E"

    if short:
        return "%s.%s%s%s%s" % (_pcMajor, _pcMinor, _pcStatus, _pcRevision, utype);

    stype = ""
    if _pcStatus == "A":
        stype = "Alpha"
    elif _pcStatus == "B":
        stype = "Beta"
    elif _pcStatus == "RC":
        stype = "Release Candidate"

    if utype == "E":
        utype = " Bleeding Edge"

    return "%s.%s %s %s%s" % (_pcMajor, _pcMinor, stype, _pcRevision, utype);

# Naughty I know, but it lets me grab it from the bash script.
if __name__ == "__main__":
    print lexVersion()

def verStrToNum(ver):
    w = re.match("(\d+\.?\d+)\.(\d+)-?([A-Za-z]{0,2})\.?(\d*):(\S+)", ver)
    if not w:
        print "Update check Failure: 3"; return
    full = ver[:ver.find(":")]
    return full,w.group(1),w.group(2),w.group(3),w.group(4),w.group(5)

def is_outdated(url=None):
    if not url:
        global _updateCheckURL
        url = _updateCheckURL

    # karxi: Do we really need to sleep here? Why?
    time.sleep(3)
    try:
        jsfile = urllib.urlopen(_updateCheckURL)
        gitver = get_pchum_ver(raw=2, file=jsfile)
    except:
        # No error handling yet....
        raise
    finally:
        jsfile.close()
    ourver = get_pchum_ver(raw=2)

    # Now we can compare.
    outdated = False
    # What, if anything, tipped us off
    trigger = None
    keys = ("major", "minor", "rev", "status")
    for k in keys:
        if gitver[k] > ourver[k]:
            # We don't test for 'bleeding edge' just yet.
            trigger = k
            outdated = True
    if outdated:
        logger.info(
            "Out of date (newer is {0!r} {1} to our {2})".format(
                trigger, gitver[trigger], ourver[trigger]))
    return outdated
# So now all that's left to do is to set up the actual downloading of
# updates...or at least a notifier, until it can be automated.

def updatePesterchum(url=None):
    # TODO: This is still WIP; the actual copying needs to be adjusted.
    if url is None:
        global _downloadURL
        url = _downloadURL

    try:
        # Try to fetch the update.
        fn, fninfo = urllib.urlretrieve(url)
    except urllib.ContentTooShortError:
        # Our download was interrupted; there's not really anything we can do
        # here.
        raise

    ext = osp.splitext(fn)

    if ext == ".zip":
        import zipfile
        is_updatefile = zipfile.is_zipfile
        openupdate = zipfile.ZipFile
    elif tarfile and ext.startswith(".tar"):
        import tarfile
        is_updatefile = tarfile.is_tarfile
        openupdate = tarfile.open
    else:
        logger.info("No handler available for update {0!r}".format(fn))
        return
    logger.info("Opening update {0!s} {1!r} ...".format(ext, fn))

    if is_updatefile(fn):
        update = openupdate(fn, 'r')
        tmpfldr, updfldr = "tmp", "update"

        # Set up the folder structure.
        if osp.exists(updfldr):
            # We'll need this later.
            shutil.rmtree(updfldr)
        if osp.exists(tmpfldr):
            shutil.rmtree(tmpfldr)
        os.mkdir(tmpfldr)
        update.extractall(tmpfldr)
        contents = os.listdir(tmpfldr)

        # Is there only one folder here? Git likes to do this with repos.
        # If there is, move it to our update folder.
        # If there isn't, move the temp directory to our update folder.
        if len(tmpcts) == 1:
            arcresult = osp.join(tmpfldr, contents[0])
            if osp.isdir(arcresult):
                shutil.move(arcresult, updfldr)
        else:
            shutil.move(tmpfldr, updfldr)
        # Remove the temporary folder.
        os.rmdir(tmpfldr)
        # Remove the update file.
        os.remove(fn)
        # ... What does this even do? It recurses....
        removeCopies(updfldr)
        # Why do these both skip the first seven characters?!
        copyUpdate(updfldr)

        # Finally, remove the update folder.
        shutil.rmtree(updfldr)

def updateCheck(q):
    # karxi: Disabled for now; causing issues.
    # There should be an alternative system in place soon.
    return q.put((False,0))

    time.sleep(3)
    data = urllib.urlencode({"type" : USER_TYPE, "os" : OS_TYPE, "install" : INSTALL_TYPE})
    try:
        f = urllib.urlopen("http://distantsphere.com/pesterchum.php?" + data)
    except:
        print "Update check Failure: 1"; return q.put((False,1))
    newest = f.read()
    f.close()
    if not newest or newest[0] == "<":
        print "Update check Failure: 2"; return q.put((False,2))
    try:
        (full, major, minor, status, revision, url) = verStrToNum(newest)
    except TypeError:
        return q.put((False,3))
    print full
    print repr(verStrToNum(newest))

    if major <= _pcMajor:
        if minor <= _pcMinor:
            if status:
                if status <= _pcStatus:
                    if revision <= _pcRevision:
                        return q.put((False,0))
            else:
                if not _pcStatus:
                    if revision <= _pcRevision:
                        return q.put((False,0))
    print "A new version of Pesterchum is avaliable!"
    q.put((full,url))


def removeCopies(path):
    for f in os.listdir(path):
        filePath = osp.join(path, f)
        trunc, rem = filePath[:7], filePath[7:]
        if not osp.isdir(filePath):
            if osp.exists(rem):
                logger.debug(
                    "{0: <4}Deleting copy: {1!r} >{2!r}<".format(
                        '', trunc, rem)
                )
                os.remove(rem)
        else:
            # Recurse
            removeCopies(filePath)

def copyUpdate(path):
    for f in os.listdir(path):
        filePath = osp.join(path, f)
        trunc, rem = filePath[:7], filePath[7:]
        if not osp.isdir(filePath):
            logger.debug(
                "{0: <4}Making copy: {1!r} ==> {2!r}".format(
                    '', filePath, rem)
            )
            shutil.copy2(filePath, rem)
        else:
            if not osp.exists(rem):
                os.mkdir(rem)
            # Recurse
            copyUpdate(filePath)

def updateExtract(url, extension):
    if extension:
        fn = "update" + extension
        urllib.urlretrieve(url, fn)
    else:
        fn = urllib.urlretrieve(url)[0]
        if tarfile and tarfile.is_tarfile(fn):
            extension = ".tar.gz"
        elif zipfile.is_zipfile(fn):
            extension = ".zip"
        else:
            try:
                from libs import magic # :O I'M IMPORTING /MAGIC/!! HOLY SHIT!
                mime = magic.from_file(fn, mime=True)
                if mime == 'application/octet-stream':
                    extension = ".exe"
            except:
                pass

    print url, fn, extension

    if extension == ".exe":
        pass
    elif extension == ".zip" or extension.startswith(".tar"):
        if extension == ".zip":
            from zipfile import is_zipfile as is_updatefile, ZipFile as openupdate
            print "Opening .zip"
        elif tarfile and extension.startswith(".tar"):
            from tarfile import is_tarfile as is_updatefile, open as openupdate
            print "Opening .tar"
        else:
            return

        if is_updatefile(fn):
            update = openupdate(fn, 'r')
            if os.path.exists("tmp"):
                shutil.rmtree("tmp")
            os.mkdir("tmp")
            update.extractall("tmp")
            tmp = os.listdir("tmp")
            if os.path.exists("update"):
                shutil.rmtree("update")
            if len(tmp) == 1 and \
               os.path.isdir("tmp/"+tmp[0]):
                shutil.move("tmp/"+tmp[0], "update")
            else:
                shutil.move("tmp", "update")
            os.rmdir("tmp")
            os.remove(fn)
            removeCopies("update")
            copyUpdate("update")
            shutil.rmtree("update")

def updateDownload(url):
    extensions = [".exe", ".zip", ".tar.gz", ".tar.bz2"]
    found = False
    for e in extensions:
        if url.endswith(e):
            found = True
            updateExtract(url, e)
    if not found:
        if url.startswith("https://github.com/") and url.count('/') == 4:
            updateExtract(url+"/tarball/master", None)
        else:
            updateExtract(url, None)