google-nomulus/java/google/registry/builddefs/zip_file.bzl

# Copyright 2017 The Nomulus Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Zip file creator that allows arbitrary path renaming.

This rule takes two main inputs: a bunch of filesets and a dictionary of
hard-coded source to dest mappings. It then applies those mappings to the input
file paths, to create a zip file with the same name as the rule.

The following preconditions must be met:

- Sources and destinations can't begin or end with slash.
- Every file must be matched by a mapping.
- Every mapping must match something.

The source can either be an exact match or a prefix.

- If a match is exact, the destination replaces the entire path. If the
  destination path is empty, then the path remains the same.

- If the match is a prefix, then the destination replaces the source prefix in
  the path. If the destination is empty, then the source prefix is removed.

- If source is an empty string, it matches everything. In this case,
  destination becomes the path prefix.

Prefixes are matched with component granularity, not characters. Mappings with
more components take precedence. Mappings with equal components are sorted
asciibetically.

Mappings apply to the "long path" of a file, i.e. relative to TEST_SRCDIR,
e.g. workspace_name/pkg/file. Long paths do not take into consideration
bazel-foo/ output directories.

The deps attribute allows zip_file() rules to depend on other zip_file() rules.
In such cases, the contents of directly dependent zip files are unzipped and
then re-zipped. Mappings specified by the current rule do not apply to the
files extracted from dependent zips. However those files can be overridden.

The simplest example of this rule, which simply zips up short paths, is as
follows:

  # //my/package/BUILD
  zip_file(
      name = "doodle",
      srcs = ["hello.txt"],
      mappings = {"": ""},
  )

The rule above would create a zip file name //my/package/doodle.zip which would
contain a single file named "my/package/hello.txt".

If we wanted to strip the package path, we could do the following:

  # //my/package/BUILD
  zip_file(
      name = "doodle",
      srcs = ["hello.txt"],
      mappings = {"my/package": ""},
  )

In this case, doodle.zip would contain a single file: "hello.txt".

If we wanted to rename hello.txt, we could do the following:

  # //my/package/BUILD
  zip_file(
      name = "doodle",
      srcs = ["hello.txt"],
      mappings = {"my/package/hello.txt": "my/package/world.txt"},
  )

A zip file can be assembled across many rules. For example:

  # //webapp/html/BUILD
  zip_file(
      name = "assets",
      srcs = glob(["*.html"]),
      mappings = {"webapp/html": ""},
  )

  # //webapp/js/BUILD
  zip_file(
      name = "assets",
      srcs = glob(["*.js"]),
      mappings = {"webapp/js": "assets/js"},
  )

  # //webapp/BUILD
  zip_file(
      name = "war",
      deps = [
          "//webapp/html:assets",
          "//webapp/js:assets",
      ],
      mappings = {"webapp/html": ""},
  )

You can exclude files with the "exclude" attribute:

  # //webapp/BUILD
  zip_file(
      name = "war_without_tears",
      deps = ["war"],
      exclude = ["assets/js/tears.js"],
  )

Note that "exclude" excludes based on the mapped path relative to the root of
the zipfile. If the file doesn't exist, you'll get an error.

"""

load('//java/google/registry/builddefs:defs.bzl',
     'ZIPPER',
     'collect_runfiles',
     'long_path')

def _zip_file(ctx):
  """Implementation of zip_file() rule."""
  for s, d in ctx.attr.mappings.items():
    if (s.startswith('/') or s.endswith('/') or
        d.startswith('/') or d.endswith('/')):
      fail('mappings should not begin or end with slash')
  srcs = depset()
  srcs += ctx.files.srcs
  srcs += ctx.files.data
  srcs += collect_runfiles(ctx.attr.data)
  mapped = _map_sources(ctx, srcs, ctx.attr.mappings)
  cmd = [
      '#!/bin/sh',
      'set -e',
      'repo="$(pwd)"',
      'zipper="${repo}/%s"' % ctx.file._zipper.path,
      'archive="${repo}/%s"' % ctx.outputs.out.path,
      'tmp="$(mktemp -d "${TMPDIR:-/tmp}/zip_file.XXXXXXXXXX")"',
      'cd "${tmp}"',
  ]
  cmd += ['"${zipper}" x "${repo}/%s"' % dep.zip_file.path
          for dep in ctx.attr.deps]
  cmd += ['rm %s' % filename for filename in ctx.attr.exclude]
  cmd += ['mkdir -p "${tmp}/%s"' % zip_path
          for zip_path in depset(
              [zip_path[:zip_path.rindex('/')]
               for _, zip_path in mapped if '/' in zip_path])]
  cmd += ['ln -sf "${repo}/%s" "${tmp}/%s"' % (path, zip_path)
          for path, zip_path in mapped]
  cmd += [
      ('find . | sed 1d | cut -c 3- | LC_ALL=C sort' +
       ' | xargs "${zipper}" cC "${archive}"'),
      'cd "${repo}"',
      'rm -rf "${tmp}"',
  ]
  if hasattr(ctx, 'bin_dir'):
    script = ctx.new_file(ctx.bin_dir, '%s.sh' % ctx.label.name)
  else:
    # TODO(kchodorow): remove this once Bazel 4.0+ is required.
    script = ctx.new_file(ctx.configuration.bin_dir, '%s.sh' % ctx.label.name)
  ctx.file_action(output=script, content='\n'.join(cmd), executable=True)
  inputs = [ctx.file._zipper]
  inputs += [dep.zip_file for dep in ctx.attr.deps]
  inputs += list(srcs)
  ctx.action(
      inputs=inputs,
      outputs=[ctx.outputs.out],
      executable=script,
      mnemonic='zip',
      progress_message='Creating zip with %d inputs %s' % (
          len(inputs), ctx.label))
  return struct(files=depset([ctx.outputs.out]), zip_file=ctx.outputs.out)

def _map_sources(ctx, srcs, mappings):
  """Calculates paths in zip file for srcs."""
  # order mappings with more path components first
  mappings = sorted([(-len(source.split('/')), source, dest)
                     for source, dest in mappings.items()])
  # get rid of the integer part of tuple used for sorting
  mappings = [(source, dest) for _, source, dest in mappings]
  mappings_indexes = range(len(mappings))
  used = {i: False for i in mappings_indexes}
  mapped = []
  for file_ in srcs:
    run_path = long_path(ctx, file_)
    zip_path = None
    for i in mappings_indexes:
      source = mappings[i][0]
      dest = mappings[i][1]
      if not source:
        if dest:
          zip_path = dest + '/' + run_path
        else:
          zip_path = run_path
      elif source == run_path:
        if dest:
          zip_path = dest
        else:
          zip_path = run_path
      elif run_path.startswith(source + '/'):
        if dest:
          zip_path = dest + run_path[len(source):]
        else:
          zip_path = run_path[len(source) + 1:]
      else:
        continue
      used[i] = True
      break
    if not zip_path:
      fail('no mapping matched: ' + run_path)
    mapped += [(file_.path, zip_path)]
  for i in mappings_indexes:
    if not used[i]:
      fail('superfluous mapping: "%s" -> "%s"' % mappings[i])
  return mapped

zip_file = rule(
    implementation=_zip_file,
    output_to_genfiles = True,
    attrs={
        'out': attr.output(mandatory=True),
        'srcs': attr.label_list(allow_files=True),
        'data': attr.label_list(cfg='data', allow_files=True),
        'deps': attr.label_list(providers=['zip_file']),
        'exclude': attr.string_list(),
        'mappings': attr.string_dict(),
        '_zipper': attr.label(default=Label(ZIPPER), single_file=True),
    })