electron/script/lib/util.py

270 lines
6.2 KiB
Python
Raw Normal View History

2013-06-20 15:10:00 +00:00
#!/usr/bin/env python
import atexit
import contextlib
2013-06-20 15:10:00 +00:00
import errno
import hashlib
2015-07-01 09:17:44 +00:00
import platform
import re
import shutil
2015-02-10 09:52:33 +00:00
import ssl
import subprocess
import sys
import tarfile
import tempfile
import urllib2
2013-06-20 15:10:00 +00:00
import os
import zipfile
from config import is_verbose_mode, s3_config
2016-05-10 03:44:56 +00:00
from env_util import get_vs_env
BOTO_DIR = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'vendor',
'boto'))
2015-07-01 09:17:44 +00:00
def get_host_arch():
"""Returns the host architecture with a predictable string."""
host_arch = platform.machine()
# Convert machine type to format recognized by gyp.
if re.match(r'i.86', host_arch) or host_arch == 'i86pc':
host_arch = 'ia32'
elif host_arch in ['x86_64', 'amd64']:
host_arch = 'x64'
elif host_arch.startswith('arm'):
host_arch = 'arm'
# platform.machine is based on running kernel. It's possible to use 64-bit
# kernel with 32-bit userland, e.g. to give linker slightly more memory.
# Distinguish between different userland bitness by querying
# the python binary.
if host_arch == 'x64' and platform.architecture()[0] == '32bit':
host_arch = 'ia32'
return host_arch
2013-06-20 15:10:00 +00:00
def tempdir(prefix=''):
directory = tempfile.mkdtemp(prefix=prefix)
atexit.register(shutil.rmtree, directory)
2013-06-20 15:10:00 +00:00
return directory
2014-08-12 12:28:18 +00:00
@contextlib.contextmanager
def scoped_cwd(path):
cwd = os.getcwd()
os.chdir(path)
try:
yield
finally:
os.chdir(cwd)
@contextlib.contextmanager
def scoped_env(key, value):
origin = ''
if key in os.environ:
origin = os.environ[key]
os.environ[key] = value
try:
yield
finally:
os.environ[key] = origin
2013-06-20 15:10:00 +00:00
def download(text, url, path):
safe_mkdir(os.path.dirname(path))
with open(path, 'wb') as local_file:
2015-02-10 09:52:33 +00:00
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context
2013-06-20 15:10:00 +00:00
web_file = urllib2.urlopen(url)
file_size = int(web_file.info().getheaders("Content-Length")[0])
downloaded_size = 0
block_size = 128
2014-02-17 09:50:25 +00:00
ci = os.environ.get('CI') == '1'
while True:
buf = web_file.read(block_size)
if not buf:
break
downloaded_size += len(buf)
local_file.write(buf)
2014-02-17 09:50:25 +00:00
if not ci:
percent = downloaded_size * 100. / file_size
status = "\r%s %10d [%3.1f%%]" % (text, downloaded_size, percent)
print status,
2014-02-17 09:50:25 +00:00
if ci:
print "%s done." % (text)
else:
print
return path
def extract_tarball(tarball_path, member, destination):
with tarfile.open(tarball_path) as tarball:
tarball.extract(member, destination)
def extract_zip(zip_path, destination):
if sys.platform == 'darwin':
# Use unzip command on Mac to keep symbol links in zip file work.
execute(['unzip', zip_path, '-d', destination])
else:
with zipfile.ZipFile(zip_path) as z:
z.extractall(destination)
def make_zip(zip_file_path, files, dirs):
safe_unlink(zip_file_path)
if sys.platform == 'darwin':
files += dirs
execute(['zip', '-r', '-y', zip_file_path] + files)
else:
zip_file = zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED)
for filename in files:
zip_file.write(filename, filename)
for dirname in dirs:
for root, _, filenames in os.walk(dirname):
for f in filenames:
zip_file.write(os.path.join(root, f))
zip_file.close()
upload_zip_sha256_checksum(zip_file_path)
def upload_zip_sha256_checksum(zip_file_path):
bucket, access_key, secret_key = s3_config()
checksum_path = '{}.sha256sum'.format(zip_file_path)
safe_unlink(checksum_path)
sha256 = hashlib.sha256()
with open(zip_file_path, 'rb') as f:
sha256.update(f.read())
zip_basename = os.path.basename(zip_file_path)
with open(checksum_path, 'w') as checksum:
checksum.write('{} *{}'.format(sha256.hexdigest(), zip_basename))
s3put(bucket, access_key, secret_key, os.path.dirname(checksum_path),
'atom-shell/tmp', [checksum_path])
def rm_rf(path):
try:
shutil.rmtree(path)
2015-07-03 07:07:11 +00:00
except OSError:
pass
def safe_unlink(path):
try:
os.unlink(path)
except OSError as e:
if e.errno != errno.ENOENT:
raise
def safe_mkdir(path):
try:
os.makedirs(path)
except OSError as e:
if e.errno != errno.EEXIST:
raise
2013-08-12 07:01:05 +00:00
def execute(argv, env=os.environ):
if is_verbose_mode():
2014-12-07 15:42:59 +00:00
print ' '.join(argv)
try:
output = subprocess.check_output(argv, stderr=subprocess.STDOUT, env=env)
if is_verbose_mode():
print output
return output
except subprocess.CalledProcessError as e:
print e.output
raise e
def execute_stdout(argv, env=os.environ):
if is_verbose_mode():
print ' '.join(argv)
try:
subprocess.check_call(argv, env=env)
except subprocess.CalledProcessError as e:
print e.output
raise e
else:
execute(argv, env)
2016-05-25 16:10:46 +00:00
def electron_gyp():
SOURCE_ROOT = os.path.abspath(os.path.join(__file__, '..', '..', '..'))
2016-03-31 16:23:04 +00:00
gyp = os.path.join(SOURCE_ROOT, 'electron.gyp')
with open(gyp) as f:
obj = eval(f.read());
return obj['variables']
2016-05-24 17:27:46 +00:00
def get_electron_version():
2016-05-25 16:10:46 +00:00
return 'v' + electron_gyp()['version%']
def parse_version(version):
if version[0] == 'v':
version = version[1:]
vs = version.split('.')
if len(vs) > 4:
return vs[0:4]
else:
return vs + ['0'] * (4 - len(vs))
def boto_path_dirs():
return [
2015-07-03 14:52:26 +00:00
os.path.join(BOTO_DIR, 'build', 'lib'),
os.path.join(BOTO_DIR, 'build', 'lib.linux-x86_64-2.7')
]
def run_boto_script(access_key, secret_key, script_name, *args):
env = os.environ.copy()
env['AWS_ACCESS_KEY_ID'] = access_key
env['AWS_SECRET_ACCESS_KEY'] = secret_key
env['PYTHONPATH'] = os.path.pathsep.join(
[env.get('PYTHONPATH', '')] + boto_path_dirs())
boto = os.path.join(BOTO_DIR, 'bin', script_name)
2015-07-03 14:52:26 +00:00
args = [
2015-07-03 14:52:26 +00:00
sys.executable,
boto
] + args
execute(args, env)
def s3put(bucket, access_key, secret_key, prefix, key_prefix, files):
args = [
'--bucket', bucket,
'--prefix', prefix,
'--key_prefix', key_prefix,
'--grant', 'public-read'
] + files
run_boto_script(access_key, secret_key, 's3put', *args)
2016-05-10 03:44:56 +00:00
def import_vs_env(target_arch):
if sys.platform != 'win32':
2016-05-10 03:44:56 +00:00
return
if target_arch == 'ia32':
vs_arch = 'amd64_x86'
else:
vs_arch = 'x86_amd64'
env = get_vs_env('14.0', vs_arch)
os.environ.update(env)