Remove the unused subcommands of the Python dossier code signing tool.

Cherry-pick: 0aa0d31

Author: nglevin

tools/dossier_codesigningtool/dossier_codesigningtool.py

@@ -19,13 +19,11 @@
 import json
 import os
 import os.path
-import plistlib
-import re
 import shutil
 import subprocess
 import sys
 import tempfile
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Union
 import uuid
 
 from tools.dossier_codesigningtool import dossier_codesigning_reader as dossier_reader
@@ -34,57 +32,13 @@
 _ManifestJsonValue = Union[str, List[str], Dict[str, str]]
 
 
-class DossierDirectory(object):
-  """Class to manage dossier directories.
-
-  Must used as a context manager.
-
-  Attributes:
-    path: The string path to the directory.
-    unzipped: A boolean indicating if the dossier was unzipped or already was a
-      directory.
-  """
-
-  def __init__(self, path, unzipped):
-    self.path = path
-    self.unzipped = unzipped
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, exception_type, exception_value, traceback):
-    if self.unzipped:
-      shutil.rmtree(self.path)
-
-
-# Directories within a bundle that embedded bundles may be present in.
-_EMBEDDED_BUNDLE_DIRECTORY_NAMES = [
-    'AppClips', 'Extensions', 'PlugIns', 'Frameworks', 'Watch'
-]
-
-
 def generate_arg_parser():
   """Generates an argument parser for this tool."""
   parser = argparse.ArgumentParser(
       description='Tool for generating dossiers for signing iOS bundles.',
       fromfile_prefix_chars='@')
   subparsers = parser.add_subparsers(help='Sub-commands')
 
-  generate_parser = subparsers.add_parser(
-      'generate', help='Generate a dossier from a signed bundle.')
-  generate_parser.add_argument(
-      '--output',
-      required=True,
-      help='Path to output manifest dossier location.')
-  generate_parser.add_argument(
-      '--zip',
-      action='store_true',
-      help='Zip the final dossier into a file at specified location.')
-  generate_parser.add_argument(
-      '--codesign', required=True, type=str, help='Path to codesign binary')
-  generate_parser.add_argument('bundle', help='Path to the bundle')
-  generate_parser.set_defaults(func=_generate_manifest_dossier)
-
   create_parser = subparsers.add_parser('create', help='Create a dossier.')
   create_parser.add_argument(
       '--output',
@@ -127,88 +81,9 @@ def generate_arg_parser():
   )
   create_parser.set_defaults(func=_create_dossier)
 
-  embed_parser = subparsers.add_parser(
-      'embed',
-      help=(
-          'Embeds a dossier into an existing dossier. Only supports embedding'
-          ' at the top level of the existing dossier.'
-      ),
-  )
-  embed_parser.add_argument(
-      '--dossier', required=True, help='Path to dossier location to edit.')
-  embed_parser.add_argument(
-      '--embedded_relative_artifact_path',
-      required=True,
-      type=str,
-      help='Relative path of artifact the dossier to be embedded signs')
-  embed_parser.add_argument(
-      '--embedded_dossier_path',
-      required=True,
-      type=str,
-      help='Path to dossier to be embedded')
-  embed_parser.set_defaults(func=_embed_dossier)
-
   return parser
 
 
-def _extract_codesign_data(
-    bundle_path: str,
-    output_directory: str,
-    unique_id: str,
-    codesign_path: str) -> Tuple[Optional[str], Optional[str]]:
-  """Extracts codesigning data from the provided bundle to the output directory.
-
-   Given a bundle_path will extract the entitlements file to the provided
-   output_directory as well as extract the codesigning identity.
-
-  Args:
-    bundle_path: The absolute path to the bundle to extract entitlements from.
-    output_directory: The absolute path to the output directory the entitlements
-      should be placed in, it must already exist.
-    unique_id: Unique identifier to use for filename of extracted entitlements.
-    codesign_path: Path to the codesign tool as a string.
-
-  Returns:
-    A tuple of the output file name for the entitlements in the output_directory
-    and the codesigning identity. If either of these is not available, they will
-    be set to None in the tuple.
-
-  Raises:
-    OSError: If unable to extract codesign identity.
-  """
-  command = (codesign_path, '-dvv', '--entitlements', ':-', bundle_path)
-  process = subprocess.Popen(
-      command,
-      stdout=subprocess.PIPE,
-      stderr=subprocess.PIPE,
-      encoding='utf8',
-      errors='replace')
-  output, stderr = process.communicate()
-  if process.poll() != 0:
-    raise OSError('Fail to extract entitlements from bundle: %s' % stderr)
-
-  if not output:
-    return None, None
-
-  signing_info = re.search(r'^Authority=(.*)$', str(stderr), re.MULTILINE)
-  if signing_info:
-    cert_authority = signing_info.group(1)
-  else:
-    cert_authority = None
-
-  plist = plistlib.loads(output.encode('utf-8'))
-  if not plist:
-    return None, cert_authority
-
-  output_file_name = unique_id + '.entitlements'
-  output_file_path = os.path.join(output_directory, output_file_name)
-  output_file = open(output_file_path, 'w')
-  output_file.write(output)
-  output_file.close()
-
-  return output_file_name, cert_authority
-
-
 def _copy_entitlements_file(
     original_entitlements_file_path: str,
     output_directory: str,
@@ -261,40 +136,6 @@ def _copy_provisioning_profile(
   return dest_provisioning_profile_filename
 
 
-def _extract_provisioning_profile(
-    bundle_path: str,
-    output_directory: str,
-    unique_id: str) -> Optional[str]:
-  """Extracts the profile for the provided bundle to a destination file name.
-
-  Given a bundle_path will extract the profile file to the provided
-  output_directory, and return the filename relative to the output_directory
-  that the profile has been placed in, or None if no profile exists.
-
-  Args:
-    bundle_path: The absolute path to the bundle to extract profile from.
-    output_directory: The absolute path to the output directory the profile
-      should be placed in, it must already exist.
-    unique_id: Unique identifier to use for filename of extracted profile.
-
-  Returns:
-    The filename relative to output_directory the profile was placed in,
-    or None if there was no profile found.
-  """
-  embedded_mobileprovision_path = os.path.join(bundle_path,
-                                               'embedded.mobileprovision')
-  embedded_provisioning_profile_path = os.path.join(
-      bundle_path, 'Contents', 'embedded.provisionprofile')
-  if os.path.exists(embedded_mobileprovision_path):
-    original_provisioning_profile_path = embedded_mobileprovision_path
-  elif os.path.exists(embedded_provisioning_profile_path):
-    original_provisioning_profile_path = embedded_provisioning_profile_path
-  else:
-    return None
-  return _copy_provisioning_profile(original_provisioning_profile_path,
-                                    output_directory, unique_id)
-
-
 def _generate_manifest(
     codesign_identity: Optional[str],
     entitlement_file: Optional[str],
@@ -335,115 +176,6 @@ def _generate_manifest(
              .EMBEDDED_BUNDLE_MANIFESTS_KEY] = embedded_bundle_manifests
   return manifest
 
-
-def _embedded_manifests_for_path(
-    bundle_path: str,
-    dossier_directory: str,
-    target_directory: str,
-    codesign_path: str,
-) -> List[Dict[str, _ManifestJsonValue]]:
-  """Generates embedded manifests for a bundle in a sub-directory.
-
-  Provided a bundle, output directory, and a target directory, traverses the
-  target directory to find any bundles that are signed, and generate manifests.
-  Copies any referenced assets to the output directory.
-
-  Args:
-    bundle_path: The absolute path to the bundle that will be searched.
-    dossier_directory: The absolute path to the output dossier directory that
-      manifest referenced assets will be copied to.
-    target_directory: The target directory name, relative to the bundle_path, to
-      be traversed.
-    codesign_path: Path to the codesign tool as a string.
-
-  Returns:
-    A list of manifest contents with the contents they reference copied into
-    dossier_directory, or an empty list if no bundles are codesigned.
-  """
-  if target_directory not in _EMBEDDED_BUNDLE_DIRECTORY_NAMES:
-    raise ValueError(
-        'Invalid bundle directory for dossier manifest: %s' % target_directory)
-
-  embedded_manifests = []
-  target_directory_path = os.path.join(bundle_path, target_directory)
-  if os.path.exists(target_directory_path):
-    target_directory_contents = os.listdir(target_directory_path)
-    target_directory_contents.sort()
-    for filename in target_directory_contents:
-      absolute_embedded_bundle_path = os.path.join(target_directory_path,
-                                                   filename)
-      embedded_manifest = _manifest_with_dossier_for_bundle(
-          absolute_embedded_bundle_path, dossier_directory, codesign_path)
-      if embedded_manifest is not None:
-        embedded_manifest[
-            dossier_reader.EMBEDDED_RELATIVE_PATH_KEY] = os.path.join(
-                target_directory, filename)
-        embedded_manifests.append(embedded_manifest)
-  return embedded_manifests
-
-
-def _manifest_with_dossier_for_bundle(
-    bundle_path: str,
-    dossier_directory: str,
-    codesign_path: str) -> Optional[Dict[str, _ManifestJsonValue]]:
-  """Generates a manifest and assets for a provided bundle.
-
-  Provided a bundle and output directory, prepares a code signing dossier by
-  generating the manifest contents for the bundle referenced and copying any
-  assets referenced by the manifest into the dossier folder.
-
-  Args:
-    bundle_path: The absolute path to the bundle that a manifest will be
-      generated for.
-    dossier_directory: The absolute path to the output dossier directory that
-      manifest referenced assets will be copied to.
-    codesign_path: Path to the codesign tool as a string.
-
-  Returns:
-    The manifest contents with files they reference copied into
-    dossier_directory.
-  """
-  unique_id = str(uuid.uuid4())
-  entitlements_file, codesign_identity = _extract_codesign_data(
-      bundle_path, dossier_directory, unique_id, codesign_path)
-  if not codesign_identity:
-    return None
-  provisioning_profile = _extract_provisioning_profile(bundle_path,
-                                                       dossier_directory,
-                                                       unique_id)
-  embedded_manifests = []
-  for embedded_bundle_directory in _EMBEDDED_BUNDLE_DIRECTORY_NAMES:
-    embedded_manifests.extend(
-        _embedded_manifests_for_path(bundle_path, dossier_directory,
-                                     embedded_bundle_directory, codesign_path))
-  if not embedded_manifests:
-    embedded_manifests = None
-  return _generate_manifest(codesign_identity, entitlements_file,
-                            provisioning_profile, embedded_manifests)
-
-
-def _generate_manifest_dossier(parsed_args: argparse.Namespace):
-  """Generates a manifest dossier for provided args."""
-  bundle_path = parsed_args.bundle
-  dossier_directory = parsed_args.output
-
-  packaging_required = False
-  if parsed_args.zip:
-    dossier_directory = tempfile.mkdtemp()
-    packaging_required = True
-
-  if not os.path.exists(dossier_directory):
-    os.makedirs(dossier_directory)
-
-  manifest = _manifest_with_dossier_for_bundle(
-      os.path.abspath(bundle_path), dossier_directory, parsed_args.codesign)
-
-  _write_manifest(manifest, dossier_directory)
-  if packaging_required:
-    _zip_dossier(dossier_directory, parsed_args.output)
-    shutil.rmtree(dossier_directory)
-
-
 def _write_manifest(
     manifest: Dict[str, _ManifestJsonValue],
     dossier_directory: str) -> None:
@@ -567,40 +299,6 @@ def _create_dossier(parsed_args: argparse.Namespace):
     shutil.rmtree(dossier_directory)
 
 
-def _embed_dossier(parsed_args):
-  """Embeds an existing dossier into the specified dossier.
-
-  Provided a set of args from generate sub-command, embeds a dossier in a
-  dossier.
-
-  Args:
-    parsed_args: A struct of arguments required for generating a dossier from a
-      signed bundle that were generated from an instance of
-      argparse.ArgumentParser(...).
-
-  Raises:
-    OSError: If any of specified dossiers are not found.
-  """
-  with (dossier_reader.extract_zipped_dossier_if_required(
-            parsed_args.dossier) as dossier_dir,
-        dossier_reader.extract_zipped_dossier_if_required(
-            parsed_args.embedded_dossier_path) as embedded_dossier_dir):
-
-    manifest = dossier_reader.read_manifest_from_dossier(dossier_dir.path)
-    embedded_manifest = dossier_reader.read_manifest_from_dossier(
-        embedded_dossier_dir.path)
-
-    _merge_dossier_contents(embedded_dossier_dir.path, dossier_dir.path)
-    embedded_manifest[dossier_reader.EMBEDDED_RELATIVE_PATH_KEY] = (
-        parsed_args.embedded_relative_artifact_path)
-    manifest[dossier_reader.EMBEDDED_BUNDLE_MANIFESTS_KEY].append(
-        embedded_manifest)
-
-    _write_manifest(manifest, dossier_dir.path)
-    if dossier_dir.unzipped:
-      _zip_dossier(dossier_dir.path, parsed_args.dossier)
-
-
 if __name__ == '__main__':
   args = generate_arg_parser().parse_args()
   sys.exit(args.func(args))