mirror of
https://github.com/google/nomulus.git
synced 2025-07-21 10:16:07 +02:00
f9636b6cea
It turns out that if the script gets super huge, then Bazel will fail in a mysterious way if you pass the script as a string to ctx.action. This way of doing things is better anyway, because this makes it much easier for the user to see the script that was actually generated for troubleshooting purposes. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=129114272
212 lines
7 KiB
Python
212 lines
7 KiB
Python
# Copyright 2016 The Domain Registry 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),
|
|
})
|