mirror of
https://github.com/google/nomulus.git
synced 2025-05-02 04:57:51 +02:00
212 lines
7 KiB
Python
212 lines
7 KiB
Python
# Copyright 2016 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 "short path" of a file, which is relative to the root of
|
|
the repository, not the current directory. Short paths do not take into
|
|
consideration bazel-foo/ output directories. Furthermore, if a file is located
|
|
in an external repository, then its short path will begin with external/foo/.
|
|
|
|
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": ""},
|
|
)
|
|
|
|
"""
|
|
|
|
load('//java/google/registry/builddefs:defs.bzl', 'ZIPPER', 'runpath')
|
|
|
|
def _impl(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')
|
|
mapped = _map_sources(ctx.files.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 += ['mkdir -p "${tmp}/%s"' % zip_path
|
|
for zip_path in set(
|
|
[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}"',
|
|
]
|
|
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 += ctx.files.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=set([ctx.outputs.out]),
|
|
zip_file=ctx.outputs.out)
|
|
|
|
def _map_sources(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:
|
|
short_path = runpath(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 + '/' + short_path
|
|
else:
|
|
zip_path = short_path
|
|
elif source == short_path:
|
|
if dest:
|
|
zip_path = dest
|
|
else:
|
|
zip_path = short_path
|
|
elif short_path.startswith(source + '/'):
|
|
if dest:
|
|
zip_path = dest + short_path[len(source):]
|
|
else:
|
|
zip_path = short_path[len(source) + 1:]
|
|
else:
|
|
continue
|
|
used[i] = True
|
|
break
|
|
if not zip_path:
|
|
fail('no mapping matched: ' + short_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=_impl,
|
|
output_to_genfiles = True,
|
|
attrs={
|
|
'out': attr.output(mandatory=True),
|
|
'srcs': attr.label_list(allow_files=True),
|
|
'deps': attr.label_list(providers=['zip_file']),
|
|
'mappings': attr.string_dict(),
|
|
'_zipper': attr.label(default=Label(ZIPPER), single_file=True),
|
|
})
|