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 int(latest['vercode']) > int(app['Current Version Code']):
 478                 logging.info("Refusing to auto update, since the latest build is newer")
 479
 480             if not gotcur:
 481                 newbuild = latest.copy()
 482                 if 'origlines' in newbuild:
 483                     del newbuild['origlines']
 484                 newbuild['disable'] = False
 485                 newbuild['vercode'] = app['Current Version Code']
 486                 newbuild['version'] = app['Current Version'] + suffix
 487                 logging.info("...auto-generating build for " + newbuild['version'])
 488                 commit = pattern.replace('%v', newbuild['version'])
 489                 commit = commit.replace('%c', newbuild['vercode'])
 490                 newbuild['commit'] = commit
 491                 app['builds'].append(newbuild)
 492                 name = common.getappname(app)
 493                 ver = common.getcvname(app)
 494                 commitmsg = "Update %s to %s" % (name, ver)
 495         else:
 496             logging.warn('Invalid auto update mode "' + mode + '" on ' + app['id'])
 497
 498     if commitmsg:
 499         metadatapath = os.path.join('metadata', app['id'] + '.txt')
 500         metadata.write_metadata(metadatapath, app)
 501         if options.commit:
 502             logging.info("Commiting update for " + metadatapath)
 503             gitcmd = ["git", "commit", "-m", commitmsg]
 504             if 'auto_author' in config:
 505                 gitcmd.extend(['--author', config['auto_author']])
 506             gitcmd.extend(["--", metadatapath])
 507             if subprocess.call(gitcmd) != 0:
 508                 logging.error("Git commit failed")
 509                 sys.exit(1)
 510
 511
 512 config = None
 513 options = None
 514
 515
 516 def main():
 517
 518     global config, options
 519
 520     # Parse command line...
 521     parser = OptionParser(usage="Usage: %prog [options] [APPID [APPID ...]]")
 522     parser.add_option("-v", "--verbose", action="store_true", default=False,
 523                       help="Spew out even more information than normal")
 524     parser.add_option("-q", "--quiet", action="store_true", default=False,
 525                       help="Restrict output to warnings and errors")
 526     parser.add_option("--auto", action="store_true", default=False,
 527                       help="Process auto-updates")
 528     parser.add_option("--autoonly", action="store_true", default=False,
 529                       help="Only process apps with auto-updates")
 530     parser.add_option("--commit", action="store_true", default=False,
 531                       help="Commit changes")
 532     parser.add_option("--gplay", action="store_true", default=False,
 533                       help="Only print differences with the Play Store")
 534     (options, args) = parser.parse_args()
 535
 536     config = common.read_config(options)
 537
 538     # Get all apps...
 539     allapps = metadata.read_metadata()
 540
 541     apps = common.read_app_args(args, allapps, False)
 542
 543     if options.gplay:
 544         for app in apps:
 545             version, reason = check_gplay(app)
 546             if version is None:
 547                 if reason == '404':
 548                     logging.info("{0} is not in the Play Store".format(common.getappname(app)))
 549                 else:
 550                     logging.info("{0} encountered a problem: {1}".format(common.getappname(app), reason))
 551             if version is not None:
 552                 stored = app['Current Version']
 553                 if not stored:
 554                     logging.info("{0} has no Current Version but has version {1} on the Play Store"
 555                                  .format(common.getappname(app), version))
 556                 elif LooseVersion(stored) < LooseVersion(version):
 557                     logging.info("{0} has version {1} on the Play Store, which is bigger than {2}"
 558                                  .format(common.getappname(app), version, stored))
 559                 else:
 560                     if stored != version:
 561                         logging.info("{0} has version {1} on the Play Store, which differs from {2}"
 562                                      .format(common.getappname(app), version, stored))
 563                     else:
 564                         logging.info("{0} has the same version {1} on the Play Store"
 565                                      .format(common.getappname(app), version))
 566         return
 567
 568     for appid, app in apps.iteritems():
 569
 570         if options.autoonly and app['Auto Update Mode'] in ('None', 'Static'):
 571             logging.debug("Nothing to do for {0}...".format(appid))
 572             continue
 573
 574         logging.info("Processing " + appid + '...')
 575
 576         checkupdates_app(app)
 577
 578     logging.info("Finished.")
 579
 580 if __name__ == "__main__":
 581     main()