script/upload.py

   1 #!/usr/bin/env python
   2
   3 import argparse
   4 import errno
   5 import hashlib
   6 import os
   7 import shutil
   8 import subprocess
   9 import sys
  10 import tempfile
  11
  12 from io import StringIO
  13 from lib.config import PLATFORM, get_target_arch, get_chromedriver_version, \
  14                        get_env_var, s3_config, get_zip_name
  15 from lib.util import electron_gyp, execute, get_electron_version, \
  16                      parse_version, scoped_cwd, s3put
  17 from lib.github import GitHub
  18
  19
  20 ELECTRON_REPO = 'electron/electron'
  21 ELECTRON_VERSION = get_electron_version()
  22
  23 PROJECT_NAME = electron_gyp()['project_name%']
  24 PRODUCT_NAME = electron_gyp()['product_name%']
  25
  26 SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
  27 OUT_DIR = os.path.join(SOURCE_ROOT, 'out', 'R')
  28 DIST_DIR = os.path.join(SOURCE_ROOT, 'dist')
  29
  30 DIST_NAME = get_zip_name(PROJECT_NAME, ELECTRON_VERSION)
  31 SYMBOLS_NAME = get_zip_name(PROJECT_NAME, ELECTRON_VERSION, 'symbols')
  32 DSYM_NAME = get_zip_name(PROJECT_NAME, ELECTRON_VERSION, 'dsym')
  33 PDB_NAME = get_zip_name(PROJECT_NAME, ELECTRON_VERSION, 'pdb')
  34
  35
  36 def main():
  37   args = parse_args()
  38
  39   if not args.publish_release:
  40     if not dist_newer_than_head():
  41       run_python_script('create-dist.py')
  42
  43     build_version = get_electron_build_version()
  44     if not ELECTRON_VERSION.startswith(build_version):
  45       error = 'Tag name ({0}) should match build version ({1})\n'.format(
  46           ELECTRON_VERSION, build_version)
  47       sys.stderr.write(error)
  48       sys.stderr.flush()
  49       return 1
  50
  51   github = GitHub(auth_token())
  52   releases = github.repos(ELECTRON_REPO).releases.get()
  53   tag_exists = False
  54   for release in releases:
  55     if not release['draft'] and release['tag_name'] == args.version:
  56       tag_exists = True
  57       break
  58
  59   release = create_or_get_release_draft(github, releases, args.version,
  60                                         tag_exists)
  61
  62   if args.publish_release:
  63     # Upload the Node SHASUMS*.txt.
  64     run_python_script('upload-node-checksums.py', '-v', ELECTRON_VERSION)
  65
  66     # Upload the index.json.
  67     run_python_script('upload-index-json.py')
  68
  69     # Create and upload the Electron SHASUMS*.txt
  70     release_electron_checksums(github, release)
  71
  72     # Press the publish button.
  73     publish_release(github, release['id'])
  74
  75     # Do not upload other files when passed "-p".
  76     return
  77
  78   # Upload Electron with GitHub Releases API.
  79   upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
  80   upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
  81   if PLATFORM == 'darwin':
  82     upload_electron(github, release, os.path.join(DIST_DIR,
  83                     'electron-api.json'))
  84     upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
  85   elif PLATFORM == 'win32':
  86     upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME))
  87
  88   # Upload free version of ffmpeg.
  89   ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
  90   upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))
  91
  92   # Upload chromedriver and mksnapshot for minor version update.
  93   if parse_version(args.version)[2] == '0':
  94     chromedriver = get_zip_name('chromedriver', get_chromedriver_version())
  95     upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
  96     mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
  97     upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))
  98
  99   if PLATFORM == 'win32' and not tag_exists:
 100     # Upload PDBs to Windows symbol server.
 101     run_python_script('upload-windows-pdb.py')
 102
 103     # Upload node headers.
 104     run_python_script('upload-node-headers.py', '-v', args.version)
 105
 106
 107 def parse_args():
 108   parser = argparse.ArgumentParser(description='upload distribution file')
 109   parser.add_argument('-v', '--version', help='Specify the version',
 110                       default=ELECTRON_VERSION)
 111   parser.add_argument('-p', '--publish-release',
 112                       help='Publish the release',
 113                       action='store_true')
 114   return parser.parse_args()
 115
 116
 117 def run_python_script(script, *args):
 118   script_path = os.path.join(SOURCE_ROOT, 'script', script)
 119   return execute([sys.executable, script_path] + list(args))
 120
 121
 122 def get_electron_build_version():
 123   if get_target_arch() == 'arm' or os.environ.has_key('CI'):
 124     # In CI we just build as told.
 125     return ELECTRON_VERSION
 126   if PLATFORM == 'darwin':
 127     electron = os.path.join(SOURCE_ROOT, 'out', 'R',
 128                               '{0}.app'.format(PRODUCT_NAME), 'Contents',
 129                               'MacOS', PRODUCT_NAME)
 130   elif PLATFORM == 'win32':
 131     electron = os.path.join(SOURCE_ROOT, 'out', 'R',
 132                               '{0}.exe'.format(PROJECT_NAME))
 133   else:
 134     electron = os.path.join(SOURCE_ROOT, 'out', 'R', PROJECT_NAME)
 135
 136   return subprocess.check_output([electron, '--version']).strip()
 137
 138
 139 def dist_newer_than_head():
 140   with scoped_cwd(SOURCE_ROOT):
 141     try:
 142       head_time = subprocess.check_output(['git', 'log', '--pretty=format:%at',
 143                                            '-n', '1']).strip()
 144       dist_time = os.path.getmtime(os.path.join(DIST_DIR, DIST_NAME))
 145     except OSError as e:
 146       if e.errno != errno.ENOENT:
 147         raise
 148       return False
 149
 150   return dist_time > int(head_time)
 151
 152
 153 def get_text_with_editor(name):
 154   editor = os.environ.get('EDITOR', 'nano')
 155   initial_message = '\n# Please enter the body of your release note for %s.' \
 156                     % name
 157
 158   t = tempfile.NamedTemporaryFile(suffix='.tmp', delete=False)
 159   t.write(initial_message)
 160   t.close()
 161   subprocess.call([editor, t.name])
 162
 163   text = ''
 164   for line in open(t.name, 'r'):
 165     if len(line) == 0 or line[0] != '#':
 166       text += line
 167
 168   os.unlink(t.name)
 169   return text
 170
 171 def create_or_get_release_draft(github, releases, tag, tag_exists):
 172   # Search for existing draft.
 173   for release in releases:
 174     if release['draft']:
 175       return release
 176
 177   if tag_exists:
 178     tag = 'do-not-publish-me'
 179   return create_release_draft(github, tag)
 180
 181
 182 def create_release_draft(github, tag):
 183   name = '{0} {1}'.format(PROJECT_NAME, tag)
 184   if os.environ.has_key('CI'):
 185     body = '(placeholder)'
 186   else:
 187     body = get_text_with_editor(name)
 188   if body == '':
 189     sys.stderr.write('Quit due to empty release note.\n')
 190     sys.exit(0)
 191
 192   data = dict(tag_name=tag, name=name, body=body, draft=True)
 193   r = github.repos(ELECTRON_REPO).releases.post(data=data)
 194   return r
 195
 196
 197 def release_electron_checksums(github, release):
 198   checksums = run_python_script('merge-electron-checksums.py',
 199                                 '-v', ELECTRON_VERSION)
 200   upload_io_to_github(github, release, 'SHASUMS256.txt',
 201                       StringIO(checksums.decode('utf-8')), 'text/plain')
 202
 203
 204 def upload_electron(github, release, file_path):
 205   # Delete the original file before uploading in CI.
 206   filename = os.path.basename(file_path)
 207   if os.environ.has_key('CI'):
 208     try:
 209       for asset in release['assets']:
 210         if asset['name'] == filename:
 211           github.repos(ELECTRON_REPO).releases.assets(asset['id']).delete()
 212     except Exception:
 213       pass
 214
 215   # Upload the file.
 216   with open(file_path, 'rb') as f:
 217     upload_io_to_github(github, release, filename, f, 'application/zip')
 218
 219   # Upload the checksum file.
 220   upload_sha256_checksum(release['tag_name'], file_path)
 221
 222   # Upload ARM assets without the v7l suffix for backwards compatibility
 223   # TODO Remove for 2.0
 224   if 'armv7l' in filename:
 225     arm_filename = filename.replace('armv7l', 'arm')
 226     arm_file_path = os.path.join(os.path.dirname(file_path), arm_filename)
 227     shutil.copy2(file_path, arm_file_path)
 228     upload_electron(github, release, arm_file_path)
 229
 230
 231 def upload_io_to_github(github, release, name, io, content_type):
 232   params = {'name': name}
 233   headers = {'Content-Type': content_type}
 234   github.repos(ELECTRON_REPO).releases(release['id']).assets.post(
 235       params=params, headers=headers, data=io, verify=False)
 236
 237
 238 def upload_sha256_checksum(version, file_path):
 239   bucket, access_key, secret_key = s3_config()
 240   checksum_path = '{}.sha256sum'.format(file_path)
 241   sha256 = hashlib.sha256()
 242   with open(file_path, 'rb') as f:
 243     sha256.update(f.read())
 244
 245   filename = os.path.basename(file_path)
 246   with open(checksum_path, 'w') as checksum:
 247     checksum.write('{} *{}'.format(sha256.hexdigest(), filename))
 248   s3put(bucket, access_key, secret_key, os.path.dirname(checksum_path),
 249         'atom-shell/tmp/{0}'.format(version), [checksum_path])
 250
 251
 252 def publish_release(github, release_id):
 253   data = dict(draft=False)
 254   github.repos(ELECTRON_REPO).releases(release_id).patch(data=data)
 255
 256
 257 def auth_token():
 258   token = get_env_var('GITHUB_TOKEN')
 259   message = ('Error: Please set the $ELECTRON_GITHUB_TOKEN '
 260              'environment variable, which is your personal token')
 261   assert token, message
 262   return token
 263
 264
 265 if __name__ == '__main__':
 266   import sys
 267   sys.exit(main())