Issue 4028 - Add support for Edge extensions to buildtools

packagerEdge.py

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import base64
 import hashlib
 import json
 import mimetypes
 import os
-import sys
 import zipfile
 
 import packager
 import packagerChrome
 
 # Files and directories expected inside of the .APPX archive.
 MANIFEST = 'AppxManifest.xml'
 CONTENT_TYPES = '[Content_Types].xml'
 BLOCKMAP = 'AppxBlockMap.xml'
 EXTENSION_DIR = 'Extension'
@@ skipping 26 matching lines @@
         'lfh_size': _lfh_size(filename),
         'blocks': [
             {'hash': base64.b64encode(hashlib.sha256(block).digest())}
             for block in blocks
         ]
     }
 
 
 def create_appx_blockmap(files):
     """Create APPX blockmap for the list of files."""
+    # We don't support AppxBlockmap.xml generation for compressed zip files at
+    # the moment. The only way to reliably calculate the compressed size of
+    # each 64k chunk in the zip file is to override the relevant parts of
+    # `zipfile` library. We have chosen to not do it so we produce an
+    # uncompressed zip file that is later repackaged by Windows Store with
+    # compression.
     template = _get_template_for(BLOCKMAP)
     files = [_make_blockmap_entry(n, d) for n, d in files.items()]
     return template.render(files=files).encode('utf-8')
 
 
 def load_translation(files, locale):
     """Load translation strings for locale from files."""
     path = '{}/_locales/{}/messages.json'.format(EXTENSION_DIR, locale)
     return json.loads(files[path])
 
 
-def create_appx_manifest(params, files):
+def pad_version(version):
+    """Make sure version number has 4 groups of digits."""
+    groups = (version.split('.') + ['0', '0', '0'])[:4]
+    return '.'.join(groups)
+
+
+def create_appx_manifest(params, files, release_build=False):
     """Create AppxManifest.xml."""
     params = dict(params)
     metadata = params['metadata']
     w = params['windows_version'] = {}
     w['min'], w['max'] = metadata.get('compat', 'windows').split('/')
     params.update(metadata.items('general'))
+    params['version'] = pad_version(params['version'])
 
     translation = load_translation(files, defaultLocale)
-    params['display_name'] = translation['name']
-    params['description'] = translation['description']
+    name_key = 'name' if release_build else 'name_devbuild'
+    params['display_name'] = translation[name_key]['message']
+    params['description'] = translation['description']['message']
 
     for size in ['44', '50', '150']:
         path = '{}/logo_{}.png'.format(ASSETS_DIR, size)
         if path not in files:
             raise KeyError(path + 'is not found in files')
         params['logo_' + size] = path.replace('/', '\\')
-
-    expected_id = '{}.{}'.format(params['author'],
-                                 params['display_name']).replace(' ', '')
-    if params['app_id'] != expected_id:
-        sys.stderr.write(
-            "WARNING: app_id doesn't match author and display_name: "
-            "'{app_id}' and '{author}' + '{display_name}'\n".format(**params)
-        )
 
     template = _get_template_for(MANIFEST)
     return template.render(params).encode('utf-8')
 
 
 def move_files_to_extension(files):
     """Move all files into `Extension` folder for APPX packaging."""
     # We sort the files to ensure that 'Extension/xyz' is moved before 'xyz'.
     # If 'xyz' is moved first, it would overwrite 'Extension/xyz' and its
     # original content would be lost.
@@ skipping 28 matching lines @@
     metadata = packager.readMetadata(baseDir, type)
     version = packager.getBuildVersion(baseDir, metadata, releaseBuild,
                                        buildNum)
 
     outfile = outFile or packager.getDefaultFileName(metadata, version, 'appx')
 
     params = {
         'type': type,
         'baseDir': baseDir,
         'releaseBuild': releaseBuild,
         'version': version,

[Sebastian Noack, 2016/10/12 14:43:27]

As figured out during testing, and discussed on IRC, the version must have 4
parts. So we should bad it with zeros here.

[Vasily Kuznetsov, 2016/10/13 11:56:36]

I've done it inside of appx manifest generation instead. Should be fine too.

         'devenv': devenv,
         'metadata': metadata,
     }
 
     files = packager.Files(packagerChrome.getPackageFiles(params),
                            packagerChrome.getIgnoredFiles(params))
 
     if metadata.has_section('mapping'):
         mapped = metadata.items('mapping')
         files.readMappedFiles(mapped)
@@ skipping 12 matching lines @@
 
     files['manifest.json'] = packagerChrome.createManifest(params, files)
 
     move_files_to_extension(files)
 
     if metadata.has_section('appx_assets'):
         for name, path in metadata.items('appx_assets'):
             path = os.path.join(baseDir, path)
             files.read(path, '{}/{}'.format(ASSETS_DIR, name))
 
-    files[MANIFEST] = create_appx_manifest(params, files)
+    files[MANIFEST] = create_appx_manifest(params, files, releaseBuild)
+    files[BLOCKMAP] = create_appx_blockmap(files)
     files[CONTENT_TYPES] = create_content_types_map(files.keys() + [BLOCKMAP])
 
-    # We don't support AppxBlockmap.xml generation for compressed zip files at
-    # the moment. The only way to reliably calculate the compressed size of
-    # each 64k chunk in the zip file is to override the relevant parts of
-    # `zipfile` library. We have chosen to not do it so we produce an
-    # uncompressed zip file that is later repackaged by Windows Store with
-    # compression.
-    files[BLOCKMAP] = create_appx_blockmap(files)
     files.zip(outfile, compression=zipfile.ZIP_STORED)