#!/usr/bin/env python

import argparse

import os

import re

import shutil

import subprocess

import sys

from lib.config import LIBCHROMIUMCONTENT_COMMIT, BASE_URL, TARGET_PLATFORM, \

DIST_ARCH

from lib.util import scoped_cwd, rm_rf, get_atom_shell_version, make_zip, \

execute, get_chromedriver_version

ATOM_SHELL_VERSION = get_atom_shell_version()

SOURCE_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

DIST_DIR = os.path.join(SOURCE_ROOT, 'dist')

OUT_DIR = os.path.join(SOURCE_ROOT, 'out', 'Release')

SYMBOL_NAME = {

'darwin': 'libchromiumcontent.dylib.dSYM',

'linux': 'libchromiumcontent.so.dbg',

'win32': 'chromiumcontent.dll.pdb',

}[TARGET_PLATFORM]

TARGET_BINARIES = {

'darwin': [

],

'win32': [

'atom.exe',

'chromiumcontent.dll',

'content_shell.pak',

'd3dcompiler_46.dll',

'ffmpegsumo.dll',

'icudtl.dat',

'libEGL.dll',

'libGLESv2.dll',

'msvcp120.dll',

'msvcr120.dll',

'content_resources_200_percent.pak',

'ui_resources_200_percent.pak',

'vccorlib120.dll',

'xinput1_3.dll',

],

'linux': [

'atom',

'content_shell.pak',

'icudtl.dat',

'libchromiumcontent.so',

'libffmpegsumo.so',

],

}

TARGET_DIRECTORIES = {

'darwin': [

'Atom.app',

],

'win32': [

'resources',

'locales',

],

'linux': [

'resources',

'locales',

],

}

SYSTEM_LIBRARIES = [

'libudev.so',

'libgcrypt.so',

'libnotify.so',

]

def main():

rm_rf(DIST_DIR)

os.makedirs(DIST_DIR)

args = parse_args()

force_build()

download_libchromiumcontent_symbols(args.url)

create_symbols()

copy_binaries()

copy_chromedriver()

copy_license()

if TARGET_PLATFORM == 'linux':

copy_system_libraries()

create_version()

create_dist_zip()

create_chromedriver_zip()

create_symbols_zip()

def parse_args():

parser = argparse.ArgumentParser(description='Create distributions')

parser.add_argument('-u', '--url',

help='The base URL from which to download '

'libchromiumcontent (i.e., the URL you passed to '

'libchromiumcontent\'s script/upload script',

default=BASE_URL,

required=False)

return parser.parse_args()

def force_build():

build = os.path.join(SOURCE_ROOT, 'script', 'build.py')

execute([sys.executable, build, '-c', 'Release'])

def copy_binaries():

for binary in TARGET_BINARIES[TARGET_PLATFORM]:

shutil.copy2(os.path.join(OUT_DIR, binary), DIST_DIR)

for directory in TARGET_DIRECTORIES[TARGET_PLATFORM]:

shutil.copytree(os.path.join(OUT_DIR, directory),

os.path.join(DIST_DIR, directory),

symlinks=True)

def copy_chromedriver():

build = os.path.join(SOURCE_ROOT, 'script', 'build.py')

execute([sys.executable, build, '-c', 'Release', '-t', 'copy_chromedriver'])

binary = 'chromedriver'

if TARGET_PLATFORM == 'win32':

binary += '.exe'

shutil.copy2(os.path.join(OUT_DIR, binary), DIST_DIR)

def copy_license():

shutil.copy2(os.path.join(SOURCE_ROOT, 'LICENSE'), DIST_DIR)

def copy_system_libraries():

ldd = execute(['ldd', os.path.join(OUT_DIR, 'atom')])

lib_re = re.compile('\t(.*) => (.+) \(.*\)$')

for line in ldd.splitlines():

m = lib_re.match(line)

if not m:

continue

for i, library in enumerate(SYSTEM_LIBRARIES):

real_library = m.group(1)

if real_library.startswith(library):

shutil.copyfile(m.group(2), os.path.join(DIST_DIR, real_library))

SYSTEM_LIBRARIES[i] = real_library

def create_version():

version_path = os.path.join(SOURCE_ROOT, 'dist', 'version')

with open(version_path, 'w') as version_file:

version_file.write(ATOM_SHELL_VERSION)

def download_libchromiumcontent_symbols(url):

brightray_dir = os.path.join(SOURCE_ROOT, 'vendor', 'brightray', 'vendor')

target_dir = os.path.join(brightray_dir, 'download', 'libchromiumcontent')

symbols_path = os.path.join(target_dir, 'Release', SYMBOL_NAME)

if os.path.exists(symbols_path):

return

download = os.path.join(brightray_dir, 'libchromiumcontent', 'script',

'download')

subprocess.check_call([sys.executable, download, '-f', '-s', '-c',

LIBCHROMIUMCONTENT_COMMIT, url, target_dir])

def create_symbols():

directory = 'Atom-Shell.breakpad.syms'

rm_rf(os.path.join(OUT_DIR, directory))

build = os.path.join(SOURCE_ROOT, 'script', 'build.py')

subprocess.check_output([sys.executable, build, '-c', 'Release',

'-t', 'atom_dump_symbols'])

shutil.copytree(os.path.join(OUT_DIR, directory),

os.path.join(DIST_DIR, directory),

symlinks=True)

def create_dist_zip():

dist_name = 'atom-shell-{0}-{1}-{2}.zip'.format(ATOM_SHELL_VERSION,

TARGET_PLATFORM, DIST_ARCH)

zip_file = os.path.join(SOURCE_ROOT, 'dist', dist_name)

with scoped_cwd(DIST_DIR):

files = TARGET_BINARIES[TARGET_PLATFORM] + ['LICENSE', 'version']

if TARGET_PLATFORM == 'linux':

files += SYSTEM_LIBRARIES

dirs = TARGET_DIRECTORIES[TARGET_PLATFORM]

make_zip(zip_file, files, dirs)

def create_chromedriver_zip():

dist_name = 'chromedriver-{0}-{1}-{2}.zip'.format(get_chromedriver_version(),

TARGET_PLATFORM, DIST_ARCH)

zip_file = os.path.join(SOURCE_ROOT, 'dist', dist_name)

with scoped_cwd(DIST_DIR):

files = ['LICENSE']

if TARGET_PLATFORM == 'win32':

files += ['chromedriver.exe']

else:

files += ['chromedriver']

make_zip(zip_file, files, [])

def create_symbols_zip():

dist_name = 'atom-shell-{0}-{1}-{2}-symbols.zip'.format(ATOM_SHELL_VERSION,

TARGET_PLATFORM,

DIST_ARCH)

zip_file = os.path.join(SOURCE_ROOT, 'dist', dist_name)

with scoped_cwd(DIST_DIR):

files = ['LICENSE', 'version']

dirs = ['Atom-Shell.breakpad.syms']

make_zip(zip_file, files, dirs)

if __name__ == '__main__':

sys.exit(main())