fdroidserver/import.py

   1 #!/usr/bin/env python3
   2 #
   3 # import.py - part of the FDroid server tools
   4 # Copyright (C) 2010-13, Ciaran Gultnieks, ciaran@ciarang.com
   5 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU Affero General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU Affero General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Affero General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 import binascii
  21 import sys
  22 import os
  23 import shutil
  24 import urllib.request
  25 from argparse import ArgumentParser
  26 from configparser import ConfigParser
  27 import logging
  28
  29 from . import common
  30 from . import metadata
  31
  32
  33 # Get the repo type and address from the given web page. The page is scanned
  34 # in a rather naive manner for 'git clone xxxx', 'hg clone xxxx', etc, and
  35 # when one of these is found it's assumed that's the information we want.
  36 # Returns repotype, address, or None, reason
  37 def getrepofrompage(url):
  38
  39     req = urllib.request.urlopen(url)
  40     if req.getcode() != 200:
  41         return (None, 'Unable to get ' + url + ' - return code ' + str(req.getcode()))
  42     page = req.read()
  43
  44     # Works for BitBucket
  45     index = page.find('hg clone')
  46     if index != -1:
  47         repotype = 'hg'
  48         repo = page[index + 9:]
  49         index = repo.find('<')
  50         if index == -1:
  51             return (None, "Error while getting repo address")
  52         repo = repo[:index]
  53         repo = repo.split('"')[0]
  54         return (repotype, repo)
  55
  56     # Works for BitBucket
  57     index = page.find('git clone')
  58     if index != -1:
  59         repotype = 'git'
  60         repo = page[index + 10:]
  61         index = repo.find('<')
  62         if index == -1:
  63             return (None, "Error while getting repo address")
  64         repo = repo[:index]
  65         repo = repo.split('"')[0]
  66         return (repotype, repo)
  67
  68     return (None, "No information found." + page)
  69
  70
  71 config = None
  72 options = None
  73
  74
  75 def get_metadata_from_url(app, url):
  76
  77     tmp_dir = 'tmp'
  78     if not os.path.isdir(tmp_dir):
  79         logging.info("Creating temporary directory")
  80         os.makedirs(tmp_dir)
  81
  82     # Figure out what kind of project it is...
  83     projecttype = None
  84     app.WebSite = url  # by default, we might override it
  85     if url.startswith('git://'):
  86         projecttype = 'git'
  87         repo = url
  88         repotype = 'git'
  89         app.SourceCode = ""
  90         app.WebSite = ""
  91     elif url.startswith('https://github.com'):
  92         projecttype = 'github'
  93         repo = url
  94         repotype = 'git'
  95         app.SourceCode = url
  96         app.IssueTracker = url + '/issues'
  97         app.WebSite = ""
  98     elif url.startswith('https://gitlab.com/'):
  99         projecttype = 'gitlab'
 100         # git can be fussy with gitlab URLs unless they end in .git
 101         if url.endswith('.git'):
 102             url = url[:-4]
 103         repo = url + '.git'
 104         repotype = 'git'
 105         app.WebSite = url
 106         app.SourceCode = url + '/tree/HEAD'
 107         app.IssueTracker = url + '/issues'
 108     elif url.startswith('https://bitbucket.org/'):
 109         if url.endswith('/'):
 110             url = url[:-1]
 111         projecttype = 'bitbucket'
 112         app.SourceCode = url + '/src'
 113         app.IssueTracker = url + '/issues'
 114         # Figure out the repo type and adddress...
 115         repotype, repo = getrepofrompage(app.SourceCode)
 116         if not repotype:
 117             logging.error("Unable to determine vcs type. " + repo)
 118             sys.exit(1)
 119     elif url.startswith('https://') and url.endswith('.git'):
 120         projecttype = 'git'
 121         repo = url
 122         repotype = 'git'
 123         app.SourceCode = ""
 124         app.WebSite = ""
 125     if not projecttype:
 126         logging.error("Unable to determine the project type.")
 127         logging.error("The URL you supplied was not in one of the supported formats. Please consult")
 128         logging.error("the manual for a list of supported formats, and supply one of those.")
 129         sys.exit(1)
 130
 131     # Ensure we have a sensible-looking repo address at this point. If not, we
 132     # might have got a page format we weren't expecting. (Note that we
 133     # specifically don't want git@...)
 134     if ((repotype != 'bzr' and (not repo.startswith('http://') and
 135         not repo.startswith('https://') and
 136         not repo.startswith('git://'))) or
 137             ' ' in repo):
 138         logging.error("Repo address '{0}' does not seem to be valid".format(repo))
 139         sys.exit(1)
 140
 141     # Get a copy of the source so we can extract some info...
 142     logging.info('Getting source from ' + repotype + ' repo at ' + repo)
 143     build_dir = os.path.join(tmp_dir, 'importer')
 144     if os.path.exists(build_dir):
 145         shutil.rmtree(build_dir)
 146     vcs = common.getvcs(repotype, repo, build_dir)
 147     vcs.gotorevision(options.rev)
 148     root_dir = get_subdir(build_dir)
 149
 150     app.RepoType = repotype
 151     app.Repo = repo
 152
 153     return root_dir, build_dir
 154
 155
 156 config = None
 157 options = None
 158
 159
 160 def get_subdir(build_dir):
 161     if options.subdir:
 162         return os.path.join(build_dir, options.subdir)
 163
 164     return build_dir
 165
 166
 167 def main():
 168
 169     global config, options
 170
 171     # Parse command line...
 172     parser = ArgumentParser()
 173     common.setup_global_opts(parser)
 174     parser.add_argument("-u", "--url", default=None,
 175                         help="Project URL to import from.")
 176     parser.add_argument("-s", "--subdir", default=None,
 177                         help="Path to main android project subdirectory, if not in root.")
 178     parser.add_argument("--rev", default=None,
 179                         help="Allows a different revision (or git branch) to be specified for the initial import")
 180     metadata.add_metadata_arguments(parser)
 181     options = parser.parse_args()
 182     metadata.warnings_action = options.W
 183
 184     config = common.read_config(options)
 185
 186     apps = metadata.read_metadata()
 187     app = metadata.App()
 188     app.UpdateCheckMode = "Tags"
 189
 190     root_dir = None
 191     build_dir = None
 192
 193     local_metadata_files = common.get_local_metadata_files()
 194     if local_metadata_files != []:
 195         logging.error("This repo already has local metadata: %s" % local_metadata_files[0])
 196         sys.exit(1)
 197
 198     if options.url is None and os.path.isdir('.git'):
 199         app.AutoName = os.path.basename(os.getcwd())
 200         app.RepoType = 'git'
 201
 202         build = {}
 203         root_dir = get_subdir(os.getcwd())
 204         if os.path.exists('build.gradle'):
 205             build.gradle = ['yes']
 206
 207         import git
 208         repo = git.repo.Repo(root_dir)  # git repo
 209         for remote in git.Remote.iter_items(repo):
 210             if remote.name == 'origin':
 211                 url = repo.remotes.origin.url
 212                 if url.startswith('https://git'):  # github, gitlab
 213                     app.SourceCode = url.rstrip('.git')
 214                 app.Repo = url
 215                 break
 216         # repo.head.commit.binsha is a bytearray stored in a str
 217         build.commit = binascii.hexlify(bytearray(repo.head.commit.binsha))
 218         write_local_file = True
 219     elif options.url:
 220         root_dir, build_dir = get_metadata_from_url(app, options.url)
 221         build = metadata.Build()
 222         build.commit = '?'
 223         build.disable = 'Generated by import.py - check/set version fields and commit id'
 224         write_local_file = False
 225     else:
 226         logging.error("Specify project url.")
 227         sys.exit(1)
 228
 229     # Extract some information...
 230     paths = common.manifest_paths(root_dir, [])
 231     if paths:
 232
 233         version, vercode, package = common.parse_androidmanifests(paths, app)
 234         if not package:
 235             logging.error("Couldn't find package ID")
 236             sys.exit(1)
 237         if not version:
 238             logging.warn("Couldn't find latest version name")
 239         if not vercode:
 240             logging.warn("Couldn't find latest version code")
 241     else:
 242         spec = os.path.join(root_dir, 'buildozer.spec')
 243         if os.path.exists(spec):
 244             defaults = {'orientation': 'landscape', 'icon': '',
 245                         'permissions': '', 'android.api': "18"}
 246             bconfig = ConfigParser(defaults, allow_no_value=True)
 247             bconfig.read(spec)
 248             package = bconfig.get('app', 'package.domain') + '.' + bconfig.get('app', 'package.name')
 249             version = bconfig.get('app', 'version')
 250             vercode = None
 251         else:
 252             logging.error("No android or kivy project could be found. Specify --subdir?")
 253             sys.exit(1)
 254
 255     # Make sure it's actually new...
 256     if package in apps:
 257         logging.error("Package " + package + " already exists")
 258         sys.exit(1)
 259
 260     # Create a build line...
 261     build.version = version or '?'
 262     build.vercode = vercode or '?'
 263     if options.subdir:
 264         build.subdir = options.subdir
 265     if os.path.exists(os.path.join(root_dir, 'jni')):
 266         build.buildjni = ['yes']
 267
 268     metadata.post_metadata_parse(app)
 269
 270     app.builds.append(build)
 271
 272     if write_local_file:
 273         metadata.write_metadata('.fdroid.yml', app)
 274     else:
 275         # Keep the repo directory to save bandwidth...
 276         if not os.path.exists('build'):
 277             os.mkdir('build')
 278         if build_dir is not None:
 279             shutil.move(build_dir, os.path.join('build', package))
 280         with open('build/.fdroidvcs-' + package, 'w') as f:
 281             f.write(app.RepoType + ' ' + app.Repo)
 282
 283         metadatapath = os.path.join('metadata', package + '.txt')
 284         metadata.write_metadata(metadatapath, app)
 285         logging.info("Wrote " + metadatapath)
 286
 287
 288 if __name__ == "__main__":
 289     main()