fdroidserver/checkupdates.py

   1 #!/usr/bin/env python2
   2 # -*- coding: utf-8 -*-
   3 #
   4 # checkupdates.py - part of the FDroid server tools
   5 # Copyright (C) 2010-2015, Ciaran Gultnieks, ciaran@ciarang.com
   6 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   7 #
   8 # This program is free software: you can redistribute it and/or modify
   9 # it under the terms of the GNU Affero General Public License as published by
  10 # the Free Software Foundation, either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU Affero General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU Affero General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 import sys
  22 import os
  23 import re
  24 import urllib2
  25 import time
  26 import subprocess
  27 from optparse import OptionParser
  28 import traceback
  29 import HTMLParser
  30 from distutils.version import LooseVersion
  31 import logging
  32
  33 import common
  34 import metadata
  35 from common import VCSException, FDroidException
  36 from metadata import MetaDataException
  37
  38
  39 # Check for a new version by looking at a document retrieved via HTTP.
  40 # The app's Update Check Data field is used to provide the information
  41 # required.
  42 def check_http(app):
  43
  44     try:
  45
  46         if 'Update Check Data' not in app:
  47             raise FDroidException('Missing Update Check Data')
  48
  49         urlcode, codeex, urlver, verex = app['Update Check Data'].split('|')
  50
  51         vercode = "99999999"
  52         if len(urlcode) > 0:
  53             logging.debug("...requesting {0}".format(urlcode))
  54             req = urllib2.Request(urlcode, None)
  55             resp = urllib2.urlopen(req, None, 20)
  56             page = resp.read()
  57
  58             m = re.search(codeex, page)
  59             if not m:
  60                 raise FDroidException("No RE match for version code")
  61             vercode = m.group(1)
  62
  63         version = "??"
  64         if len(urlver) > 0:
  65             if urlver != '.':
  66                 logging.debug("...requesting {0}".format(urlver))
  67                 req = urllib2.Request(urlver, None)
  68                 resp = urllib2.urlopen(req, None, 20)
  69                 page = resp.read()
  70
  71             m = re.search(verex, page)
  72             if not m:
  73                 raise FDroidException("No RE match for version")
  74             version = m.group(1)
  75
  76         return (version, vercode)
  77
  78     except FDroidException:
  79         msg = "Could not complete http check for app {0} due to unknown error: {1}".format(app['id'], traceback.format_exc())
  80         return (None, msg)
  81
  82
  83 def app_matches_packagename(app, package):
  84         if not package:
  85             return False
  86         appid = app['Update Check Name'] or app['id']
  87         if appid == "Ignore":
  88             return True
  89         return appid == package
  90
  91
  92 # Check for a new version by looking at the tags in the source repo.
  93 # Whether this can be used reliably or not depends on
  94 # the development procedures used by the project's developers. Use it with
  95 # caution, because it's inappropriate for many projects.
  96 # Returns (None, "a message") if this didn't work, or (version, vercode, tag) for
  97 # the details of the current version.
  98 def check_tags(app, pattern):
  99
 100     try:
 101
 102         if app['Repo Type'] == 'srclib':
 103             build_dir = os.path.join('build', 'srclib', app['Repo'])
 104             repotype = common.getsrclibvcs(app['Repo'])
 105         else:
 106             build_dir = os.path.join('build/', app['id'])
 107             repotype = app['Repo Type']
 108
 109         if repotype not in ('git', 'git-svn', 'hg', 'bzr'):
 110             return (None, 'Tags update mode only works for git, hg, bzr and git-svn repositories currently', None)
 111
 112         if repotype == 'git-svn' and ';' not in app['Repo']:
 113             return (None, 'Tags update mode used in git-svn, but the repo was not set up with tags', None)
 114
 115         # Set up vcs interface and make sure we have the latest code...
 116         vcs = common.getvcs(app['Repo Type'], app['Repo'], build_dir)
 117
 118         vcs.gotorevision(None)
 119
 120         flavours = []
 121         if len(app['builds']) > 0:
 122             if app['builds'][-1]['subdir']:
 123                 build_dir = os.path.join(build_dir, app['builds'][-1]['subdir'])
 124             if app['builds'][-1]['gradle']:
 125                 flavours = app['builds'][-1]['gradle']
 126
 127         hpak = None
 128         htag = None
 129         hver = None
 130         hcode = "0"
 131
 132         tags = vcs.gettags()
 133         logging.debug("All tags: " + ','.join(tags))
 134         if pattern:
 135             pat = re.compile(pattern)
 136             tags = [tag for tag in tags if pat.match(tag)]
 137             logging.debug("Matching tags: " + ','.join(tags))
 138
 139         if repotype in ('git',):
 140             tags = vcs.latesttags(tags, 5)
 141             logging.debug("Latest tags: " + ','.join(tags))
 142
 143         for tag in tags:
 144             logging.debug("Check tag: '{0}'".format(tag))
 145             vcs.gotorevision(tag)
 146
 147             # Only process tags where the manifest exists...
 148             paths = common.manifest_paths(build_dir, flavours)
 149             version, vercode, package = \
 150                 common.parse_androidmanifests(paths, app['Update Check Ignore'])
 151             if not app_matches_packagename(app, package) or not version or not vercode:
 152                 continue
 153
 154             logging.debug("Manifest exists. Found version {0} ({1})"
 155                           .format(version, vercode))
 156             if int(vercode) > int(hcode):
 157                 hpak = package
 158                 htag = tag
 159                 hcode = str(int(vercode))
 160                 hver = version
 161
 162         if not hpak:
 163             return (None, "Couldn't find package ID", None)
 164         if hver:
 165             return (hver, hcode, htag)
 166         return (None, "Couldn't find any version information", None)
 167
 168     except VCSException as vcse:
 169         msg = "VCS error while scanning app {0}: {1}".format(app['id'], vcse)
 170         return (None, msg, None)
 171     except Exception:
 172         msg = "Could not scan app {0} due to unknown error: {1}".format(app['id'], traceback.format_exc())
 173         return (None, msg, None)
 174
 175
 176 # Check for a new version by looking at the AndroidManifest.xml at the HEAD
 177 # of the source repo. Whether this can be used reliably or not depends on
 178 # the development procedures used by the project's developers. Use it with
 179 # caution, because it's inappropriate for many projects.
 180 # Returns (None, "a message") if this didn't work, or (version, vercode) for
 181 # the details of the current version.
 182 def check_repomanifest(app, branch=None):
 183
 184     try:
 185
 186         if app['Repo Type'] == 'srclib':
 187             build_dir = os.path.join('build', 'srclib', app['Repo'])
 188             repotype = common.getsrclibvcs(app['Repo'])
 189         else:
 190             build_dir = os.path.join('build/', app['id'])
 191             repotype = app['Repo Type']
 192
 193         # Set up vcs interface and make sure we have the latest code...
 194         vcs = common.getvcs(app['Repo Type'], app['Repo'], build_dir)
 195
 196         if repotype == 'git':
 197             if branch:
 198                 branch = 'origin/' + branch
 199             vcs.gotorevision(branch)
 200         elif repotype == 'git-svn':
 201             vcs.gotorevision(branch)
 202         elif repotype == 'hg':
 203             vcs.gotorevision(branch)
 204         elif repotype == 'bzr':
 205             vcs.gotorevision(None)
 206
 207         flavours = []
 208         if len(app['builds']) > 0:
 209             if app['builds'][-1]['subdir']:
 210                 build_dir = os.path.join(build_dir, app['builds'][-1]['subdir'])
 211             if app['builds'][-1]['gradle']:
 212                 flavours = app['builds'][-1]['gradle']
 213
 214         if not os.path.isdir(build_dir):
 215             return (None, "Subdir '" + app['builds'][-1]['subdir'] + "'is not a valid directory")
 216
 217         paths = common.manifest_paths(build_dir, flavours)
 218
 219         version, vercode, package = \
 220             common.parse_androidmanifests(paths, app['Update Check Ignore'])
 221         if not package:
 222             return (None, "Couldn't find package ID")
 223         if not app_matches_packagename(app, package):
 224             return (None, "Package ID mismatch - got {0}".format(package))
 225         if not version:
 226             return (None, "Couldn't find latest version name")
 227         if not vercode:
 228             if "Ignore" == version:
 229                 return (None, "Latest version is ignored")
 230             return (None, "Couldn't find latest version code")
 231
 232         vercode = str(int(vercode))
 233
 234         logging.debug("Manifest exists. Found version {0} ({1})".format(version, vercode))
 235
 236         return (version, vercode)
 237
 238     except VCSException as vcse:
 239         msg = "VCS error while scanning app {0}: {1}".format(app['id'], vcse)
 240         return (None, msg)
 241     except Exception:
 242         msg = "Could not scan app {0} due to unknown error: {1}".format(app['id'], traceback.format_exc())
 243         return (None, msg)
 244
 245
 246 def check_repotrunk(app, branch=None):
 247
 248     try:
 249         if app['Repo Type'] == 'srclib':
 250             build_dir = os.path.join('build', 'srclib', app['Repo'])
 251             repotype = common.getsrclibvcs(app['Repo'])
 252         else:
 253             build_dir = os.path.join('build/', app['id'])
 254             repotype = app['Repo Type']
 255
 256         if repotype not in ('git-svn', ):
 257             return (None, 'RepoTrunk update mode only makes sense in git-svn repositories')
 258
 259         # Set up vcs interface and make sure we have the latest code...
 260         vcs = common.getvcs(app['Repo Type'], app['Repo'], build_dir)
 261
 262         vcs.gotorevision(None)
 263
 264         ref = vcs.getref()
 265         return (ref, ref)
 266     except VCSException as vcse:
 267         msg = "VCS error while scanning app {0}: {1}".format(app['id'], vcse)
 268         return (None, msg)
 269     except Exception:
 270         msg = "Could not scan app {0} due to unknown error: {1}".format(app['id'], traceback.format_exc())
 271         return (None, msg)
 272
 273
 274 # Check for a new version by looking at the Google Play Store.
 275 # Returns (None, "a message") if this didn't work, or (version, None) for
 276 # the details of the current version.
 277 def check_gplay(app):
 278     time.sleep(15)
 279     url = 'https://play.google.com/store/apps/details?id=' + app['id']
 280     headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux i686; rv:18.0) Gecko/20100101 Firefox/18.0'}
 281     req = urllib2.Request(url, None, headers)
 282     try:
 283         resp = urllib2.urlopen(req, None, 20)
 284         page = resp.read()
 285     except urllib2.HTTPError, e:
 286         return (None, str(e.code))
 287     except Exception, e:
 288         return (None, 'Failed:' + str(e))
 289
 290     version = None
 291
 292     m = re.search('itemprop="softwareVersion">[ ]*([^<]+)[ ]*</div>', page)
 293     if m:
 294         html_parser = HTMLParser.HTMLParser()
 295         version = html_parser.unescape(m.group(1))
 296
 297     if version == 'Varies with device':
 298         return (None, 'Device-variable version, cannot use this method')
 299
 300     if not version:
 301         return (None, "Couldn't find version")
 302     return (version.strip(), None)
 303
 304
 305 # Return all directories under startdir that contain any of the manifest
 306 # files, and thus are probably an Android project.
 307 def dirs_with_manifest(startdir):
 308     for r, d, f in os.walk(startdir):
 309         if any(m in f for m in [
 310                 'AndroidManifest.xml', 'pom.xml', 'build.gradle']):
 311             yield r
 312
 313
 314 # Tries to find a new subdir starting from the root build_dir. Returns said
 315 # subdir relative to the build dir if found, None otherwise.
 316 def check_changed_subdir(app):
 317
 318     if app['Repo Type'] == 'srclib':
 319         build_dir = os.path.join('build', 'srclib', app['Repo'])
 320     else:
 321         build_dir = os.path.join('build/', app['id'])
 322
 323     if not os.path.isdir(build_dir):
 324         return None
 325
 326     flavours = []
 327     if len(app['builds']) > 0 and app['builds'][-1]['gradle']:
 328         flavours = app['builds'][-1]['gradle']
 329
 330     for d in dirs_with_manifest(build_dir):
 331         logging.debug("Trying possible dir %s." % d)
 332         m_paths = common.manifest_paths(d, flavours)
 333         package = common.parse_androidmanifests(m_paths, app['Update Check Ignore'])[2]
 334         if app_matches_packagename(app, package):
 335             logging.debug("Manifest exists in possible dir %s." % d)
 336             return os.path.relpath(d, build_dir)
 337
 338     return None
 339
 340
 341 def fetch_autoname(app, tag):
 342
 343     if not app["Repo Type"] or app['Update Check Mode'] in ('None', 'Static'):
 344         return None
 345
 346     if app['Repo Type'] == 'srclib':
 347         app_dir = os.path.join('build', 'srclib', app['Repo'])
 348     else:
 349         app_dir = os.path.join('build/', app['id'])
 350
 351     try:
 352         vcs = common.getvcs(app["Repo Type"], app["Repo"], app_dir)
 353         vcs.gotorevision(tag)
 354     except VCSException:
 355         return None
 356
 357     flavours = []
 358     if len(app['builds']) > 0:
 359         if app['builds'][-1]['subdir']:
 360             app_dir = os.path.join(app_dir, app['builds'][-1]['subdir'])
 361         if app['builds'][-1]['gradle']:
 362             flavours = app['builds'][-1]['gradle']
 363
 364     logging.debug("...fetch auto name from " + app_dir)
 365     new_name = common.fetch_real_name(app_dir, flavours)
 366     commitmsg = None
 367     if new_name:
 368         logging.debug("...got autoname '" + new_name + "'")
 369         if new_name != app['Auto Name']:
 370             app['Auto Name'] = new_name
 371             if not commitmsg:
 372                 commitmsg = "Set autoname of {0}".format(common.getappname(app))
 373     else:
 374         logging.debug("...couldn't get autoname")
 375
 376     return commitmsg
 377
 378
 379 def checkupdates_app(app, first=True):
 380
 381     # If a change is made, commitmsg should be set to a description of it.
 382     # Only if this is set will changes be written back to the metadata.
 383     commitmsg = None
 384
 385     tag = None
 386     msg = None
 387     vercode = None
 388     noverok = False
 389     mode = app['Update Check Mode']
 390     if mode.startswith('Tags'):
 391         pattern = mode[5:] if len(mode) > 4 else None
 392         (version, vercode, tag) = check_tags(app, pattern)
 393         msg = vercode
 394     elif mode == 'RepoManifest':
 395         (version, vercode) = check_repomanifest(app)
 396         msg = vercode
 397     elif mode.startswith('RepoManifest/'):
 398         tag = mode[13:]
 399         (version, vercode) = check_repomanifest(app, tag)
 400         msg = vercode
 401     elif mode == 'RepoTrunk':
 402         (version, vercode) = check_repotrunk(app)
 403         msg = vercode
 404     elif mode == 'HTTP':
 405         (version, vercode) = check_http(app)
 406         msg = vercode
 407     elif mode in ('None', 'Static'):
 408         version = None
 409         msg = 'Checking disabled'
 410         noverok = True
 411     else:
 412         version = None
 413         msg = 'Invalid update check method'
 414
 415     if first and version is None and vercode == "Couldn't find package ID":
 416         logging.warn("Couldn't find any version information. Looking for a subdir change...")
 417         new_subdir = check_changed_subdir(app)
 418         if new_subdir is None:
 419             logging.warn("Couldn't find any new subdir.")
 420         else:
 421             logging.warn("Trying a new subdir: %s" % new_subdir)
 422             new_build = {}
 423             metadata.fill_build_defaults(new_build)
 424             new_build['version'] = "Ignore"
 425             new_build['vercode'] = "-1"
 426             new_build['subdir'] = new_subdir
 427             app['builds'].append(new_build)
 428             return checkupdates_app(app, first=False)
 429
 430     if version and vercode and app['Vercode Operation']:
 431         op = app['Vercode Operation'].replace("%c", str(int(vercode)))
 432         vercode = str(eval(op))
 433
 434     updating = False
 435     if version is None:
 436         logmsg = "...{0} : {1}".format(app['id'], msg)
 437         if noverok:
 438             logging.info(logmsg)
 439         else:
 440             logging.warn(logmsg)
 441     elif vercode == app['Current Version Code']:
 442         logging.info("...up to date")
 443     else:
 444         app['Current Version'] = version
 445         app['Current Version Code'] = str(int(vercode))
 446         updating = True
 447
 448     commitmsg = fetch_autoname(app, tag)
 449
 450     if updating:
 451         name = common.getappname(app)
 452         ver = common.getcvname(app)
 453         logging.info('...updating to version %s' % ver)
 454         commitmsg = 'Update CV of %s to %s' % (name, ver)
 455
 456     if options.auto:
 457         mode = app['Auto Update Mode']
 458         if mode in ('None', 'Static'):
 459             pass
 460         elif mode.startswith('Version '):
 461             pattern = mode[8:]
 462             if pattern.startswith('+'):
 463                 try:
 464                     suffix, pattern = pattern.split(' ', 1)
 465                 except ValueError:
 466                     raise MetaDataException("Invalid AUM: " + mode)
 467             else:
 468                 suffix = ''
 469             gotcur = False
 470             latest = None
 471             for build in app['builds']:
 472                 if build['vercode'] == app['Current Version Code']:
 473                     gotcur = True
 474                 if not latest or int(build['vercode']) > int(latest['vercode']):
 475                     latest = build
 476
 477             if not gotcur:
 478                 newbuild = latest.copy()
 479                 if 'origlines' in newbuild:
 480                     del newbuild['origlines']
 481                 newbuild['disable'] = False
 482                 newbuild['vercode'] = app['Current Version Code']
 483                 newbuild['version'] = app['Current Version'] + suffix
 484                 logging.info("...auto-generating build for " + newbuild['version'])
 485                 commit = pattern.replace('%v', newbuild['version'])
 486                 commit = commit.replace('%c', newbuild['vercode'])
 487                 newbuild['commit'] = commit
 488                 app['builds'].append(newbuild)
 489                 name = common.getappname(app)
 490                 ver = common.getcvname(app)
 491                 commitmsg = "Update %s to %s" % (name, ver)
 492         else:
 493             logging.warn('Invalid auto update mode "' + mode + '" on ' + app['id'])
 494
 495     if commitmsg:
 496         metafile = os.path.join('metadata', app['id'] + '.txt')
 497         metadata.write_metadata(metafile, app)
 498         if options.commit:
 499             logging.info("Commiting update for " + metafile)
 500             gitcmd = ["git", "commit", "-m", commitmsg]
 501             if 'auto_author' in config:
 502                 gitcmd.extend(['--author', config['auto_author']])
 503             gitcmd.extend(["--", metafile])
 504             if subprocess.call(gitcmd) != 0:
 505                 logging.error("Git commit failed")
 506                 sys.exit(1)
 507
 508
 509 config = None
 510 options = None
 511
 512
 513 def main():
 514
 515     global config, options
 516
 517     # Parse command line...
 518     parser = OptionParser(usage="Usage: %prog [options] [APPID [APPID ...]]")
 519     parser.add_option("-v", "--verbose", action="store_true", default=False,
 520                       help="Spew out even more information than normal")
 521     parser.add_option("-q", "--quiet", action="store_true", default=False,
 522                       help="Restrict output to warnings and errors")
 523     parser.add_option("--auto", action="store_true", default=False,
 524                       help="Process auto-updates")
 525     parser.add_option("--autoonly", action="store_true", default=False,
 526                       help="Only process apps with auto-updates")
 527     parser.add_option("--commit", action="store_true", default=False,
 528                       help="Commit changes")
 529     parser.add_option("--gplay", action="store_true", default=False,
 530                       help="Only print differences with the Play Store")
 531     (options, args) = parser.parse_args()
 532
 533     config = common.read_config(options)
 534
 535     # Get all apps...
 536     allapps = metadata.read_metadata()
 537
 538     apps = common.read_app_args(args, allapps, False)
 539
 540     if options.gplay:
 541         for app in apps:
 542             version, reason = check_gplay(app)
 543             if version is None:
 544                 if reason == '404':
 545                     logging.info("{0} is not in the Play Store".format(common.getappname(app)))
 546                 else:
 547                     logging.info("{0} encountered a problem: {1}".format(common.getappname(app), reason))
 548             if version is not None:
 549                 stored = app['Current Version']
 550                 if not stored:
 551                     logging.info("{0} has no Current Version but has version {1} on the Play Store"
 552                                  .format(common.getappname(app), version))
 553                 elif LooseVersion(stored) < LooseVersion(version):
 554                     logging.info("{0} has version {1} on the Play Store, which is bigger than {2}"
 555                                  .format(common.getappname(app), version, stored))
 556                 else:
 557                     if stored != version:
 558                         logging.info("{0} has version {1} on the Play Store, which differs from {2}"
 559                                      .format(common.getappname(app), version, stored))
 560                     else:
 561                         logging.info("{0} has the same version {1} on the Play Store"
 562                                      .format(common.getappname(app), version))
 563         return
 564
 565     for appid, app in apps.iteritems():
 566
 567         if options.autoonly and app['Auto Update Mode'] in ('None', 'Static'):
 568             logging.debug("Nothing to do for {0}...".format(appid))
 569             continue
 570
 571         logging.info("Processing " + appid + '...')
 572
 573         checkupdates_app(app)
 574
 575     logging.info("Finished.")
 576
 577 if __name__ == "__main__":
 578     main()