LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
7bdd3d35c057a71b16fce2bcab8ad018b1b6f134
android_development/build/tools/mk_sdk_repo_xml.sh
Dan Willemsen f0407b3cb8 Clean up sdk building, use built xmllint 
Instead of relying on xmllint from the path, with could come from the
host, or sometimes a built version, always use the built version
explicitly.

This does some general cleanup of these make rules as well, using fewer
global variables inside make rules, and cleaning variables up at the end
of the file. I added some missing dependencies and removed some uses of
$(TOPDIR) too.

I did not clean up the uses of `zip` that make these rules
non-deterministic, but I filed b/117562080 for that, since it could use
some larger refactoring.

Test: lunch sdk_arm64-userdebug; m sdk sdk_repo dist
Change-Id: Ia0736d5fc7475603cf31f385b3ada11d9e775259
2018-10-10 21:21:20 -07:00

470 lines
15 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
#
# Generates an SDK Repository XML based on the input files.
set -e
PROG_DIR=$(dirname $0)
TYPES="tool platform-tool build-tool platform sample doc add-on system-image source"
OSES="linux macosx windows any linux-x86 darwin"
TMP_DIR=$(mktemp -d -t sdkrepo.tmp.XXXXXXXX)
trap "rm -rf $TMP_DIR" EXIT
function debug() {
echo "DEBUG: " $@ > /dev/stderr
}
function error() {
echo "*** ERROR: " $@
usage
}
function usage() {
cat <<EOFU
Usage: $0 output.xml xml-schema [type [os zip[:dest]]*...]*
where:
- schema is one of 'repository' or 'addon'
- type is one of ${TYPES// /, } (or their plural).
- os is one of ${OSES// /, }.
There can be more than one zip for the same type
as long as they use different OSes.
Zip can be in the form "source:dest" to be renamed on the fly.
EOFU
exit 1
}
# Validate the tools we need
if [[ ! -x $(which sha1sum) ]]; then
error "Missing tool: sha1sum (Linux: apt-get install coreutils; Mac: port install md5sha1sum)"
fi
if [[ -z "$XMLLINT" ]]; then
XMLLINT=xmllint
fi
# Parse input params
OUT="$1"
[[ -z "$OUT" ]] && error "Missing output.xml name."
shift
# Get the schema filename. E.g. ".../.../sdk-repository-10.xsd". Can be relative or absolute.
SCHEMA="$1"
[[ ! -f "$SCHEMA" ]] && error "Invalid XML schema name: $SCHEMA."
shift
# Get XML:NS for SDK from the schema
# This will be something like "http://schemas.android.com/sdk/android/addon/3"
XMLNS=$(sed -n '/xmlns:sdk="/s/.*"\(.*\)".*/\1/p' "$SCHEMA")
[[ -z "$XMLNS" ]] && error "Failed to find xmlns:sdk in $SCHEMA."
#echo "## Using xmlns:sdk=$XMLNS"
# Extract the schema version number from the XMLNS, e.g. it would extract "3"
XSD_VERSION="${XMLNS##*/}"
# Get the root element from the schema. This is the first element
# which name starts with "sdk-" (e.g. sdk-repository, sdk-addon)
ROOT=$(sed -n -e '/xsd:element.*name="sdk-/s/.*name="\(sdk-[^"]*\)".*/\1/p' "$SCHEMA")
[[ -z "$ROOT" ]] && error "Failed to find root element in $SCHEMA."
#echo "## Using root element $ROOT"
# Generate XML header
cat > "$OUT" <<EOFH
<?xml version="1.0"?>
<sdk:$ROOT
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:sdk="$XMLNS">
EOFH
# check_enum value value1 value2 value3...
# returns valueN if matched or nothing.
function check_enum() {
local VALUE="$1"
local i
shift
for i in "$@"; do
if [[ "$i" == "$VALUE" ]]; then
echo "$VALUE"
break;
fi
done
}
# Definition of the attributes we read from source.properties or manifest.ini
# files and the equivalent XML element being generated.
ATTRS=(
# Columns:
# --------------------------+------------------------+----------------------
# Name read from | XML element written | Min-XSD version
# source.properties | to repository.xml | where XML can be used
# --------------------------+------------------------+----------------------
# from source.properties for repository.xml packages
Pkg.Revision revision 1
Pkg.Desc description 1
Platform.Version version 1
AndroidVersion.ApiLevel api-level 1
AndroidVersion.CodeName codename 1
Platform.IncludedAbi included-abi 5
Platform.MinToolsRev min-tools-rev 1
Platform.MinPlatformToolsRev min-platform-tools-rev 3
Sample.MinApiLevel min-api-level 2
Layoutlib.Api layoutlib/api 4
Layoutlib.Revision layoutlib/revision 4
# from source.properties for addon.xml packages
# (note that vendor is mapped to different XML elements based on the XSD version)
Extra.VendorDisplay vendor-display 4
Extra.VendorId vendor-id 4
Extra.Vendor vendor-id 4
Extra.Vendor vendor 1
Extra.NameDisplay name-display 4
Extra.Path path 1
Extra.OldPaths old-paths 3
Extra.MinApiLevel min-api-level 2
# for system-image
SystemImage.Abi abi r:3,s:1
SystemImage.TagId tag-id r:9,s:2
SystemImage.TagDisplay tag-display r:9,s:2
Addon.VendorId add-on/vendor-id s:3
Addon.VendorDisplay add-on/vendor-display s:3
# from addon manifest.ini for addon.xml packages
# (note that vendor/name are mapped to different XML elements based on the XSD version)
vendor-id vendor-id 4
vendor-display vendor-display 4
vendor vendor-display 4
vendor vendor 1
name-id name-id 4
name-display name-display 4
name name-display 4
name name 1
description description 1
api api-level 1
version revision 1
revision revision 1
)
# Start with repo-10, addon-7 and sys-img-3, we don't encode the os/arch
# in the <archive> attributes anymore. Instead we have separate elements.
function uses_new_host_os() {
if [[ "$ROOT" == "sdk-repository" && "$XSD_VERSION" -ge "10" ]]; then return 0; fi
if [[ "$ROOT" == "sdk-addon" && "$XSD_VERSION" -ge "7" ]]; then return 0; fi
if [[ "$ROOT" == "sdk-sys-img" && "$XSD_VERSION" -ge "3" ]]; then return 0; fi
return 1
}
ATTRS_ARCHIVE=(
Archive.HostOs host-os 1
Archive.HostBits host-bits 1
Archive.JvmBits jvm-bits 1
Archive.MinJvmVers min-jvm-version 1
)
# Starting with XSD repo-7 and addon-5, some revision elements are no longer just
# integers. Instead they are in major.minor.micro.preview format. This defines
# which elements. This depends on the XSD root element and the XSD version.
#
# Note: addon extra revision can't take a preview number. We don't enforce
# this in this script. Instead schema validation will fail if the extra
# source.property declares an RC and it gets inserted in the addon.xml here.
if [[ "$ROOT" == "sdk-repository" && "$XSD_VERSION" -ge 7 ]] ||
[[ "$ROOT" == "sdk-addon" && "$XSD_VERSION" -ge 5 ]]; then
FULL_REVISIONS=(
tool revision
build-tool revision
platform-tool revision
extra revision
@ min-tools-rev
@ min-platform-tools-rev
)
else
FULL_REVISIONS=()
fi
# Parse all archives.
function needs_full_revision() {
local PARENT="$1"
local ELEMENT="$2"
shift
shift
local P E
while [[ "$1" ]]; do
P=$1
E=$2
if [[ "$E" == "$ELEMENT" ]] && [[ "$P" == "@" || "$P" == "$PARENT" ]]; then
return 0 # true
fi
shift
shift
done
return 1 # false
}
# Parses and print a full revision in the form "1.2.3 rc4".
# Note that the format requires to have 1 space before the
# optional "rc" (e.g. '1 rc4', not '1rc4') and no space after
# the rc (so not '1 rc 4' either)
function write_full_revision() {
local VALUE="$1"
local EXTRA_SPACE="$2"
local KEYS="major minor micro preview"
local V K
while [[ -n "$VALUE" && -n "$KEYS" ]]; do
# Take 1st segment delimited by . or space
V="${VALUE%%[. ]*}"
# Print it
if [[ "${V:0:2}" == "rc" ]]; then
V="${V:2}"
K="preview"
KEYS=""
else
K="${KEYS%% *}"
fi
if [[ -n "$V" && -n "$K" ]]; then
echo "$EXTRA_SPACE <sdk:$K>$V</sdk:$K>"
fi
# Take the rest.
K="${KEYS#* }"
if [[ "$K" == "$KEYS" ]]; then KEYS=""; else KEYS="$K"; fi
V="${VALUE#*[. ]}"
if [[ "$V" == "$VALUE" ]]; then VALUE=""; else VALUE="$V"; fi
done
}
function parse_attributes() {
local PROPS="$1"
shift
local RESULT=""
local VALUE
local REV
local USED
local S
# Get the first letter of the schema name (e.g. sdk-repo => 'r')
# This can be r, a or s and would match the min-XSD per-schema value
# in the ATTRS list.
S=$(basename "$SCHEMA")
S="${S:4:1}"
# $1 here is the ATTRS list above.
while [[ "$1" ]]; do
# Check the version in which the attribute was introduced and
# ignore things which are too *new* for this schema. This lets
# us generate old schemas for backward compatibility purposes.
SRC=$1
DST=$2
REV=$3
if [[ $REV =~ ([ras0-9:,]+,)?$S:([0-9])(,.*)? ]]; then
# Per-schema type min-XSD revision. Format is "[<type>:rev],*]
# where type is one of r, a or s matching $S above.
REV="${BASH_REMATCH[2]}"
fi
if [[ ( $REV =~ ^[0-9]+ && $XSD_VERSION -ge $REV ) || $XSD_VERSION == $REV ]]; then
# Parse the property, if present. Any space is replaced by @
VALUE=$( grep "^$SRC=" "$PROPS" | cut -d = -f 2 | tr ' ' '@' | tr -d '\r' )
if [[ -n "$VALUE" ]]; then
# In case an XML element would be mapped multiple times,
# only use its first definition.
if [[ "${USED/$DST/}" == "$USED" ]]; then
USED="$USED $DST"
RESULT="$RESULT $DST $VALUE"
fi
fi
fi
shift
shift
shift
done
echo "$RESULT"
}
function output_attributes() {
local ELEMENT="$1"
local OUT="$2"
shift
shift
local KEY VALUE
local NODE LAST_NODE EXTRA_SPACE
while [[ "$1" ]]; do
KEY="$1"
VALUE="${2//@/ }"
NODE="${KEY%%/*}"
KEY="${KEY##*/}"
if [[ "$NODE" == "$KEY" ]]; then
NODE=""
EXTRA_SPACE=""
fi
if [[ "$NODE" != "$LAST_NODE" ]]; then
EXTRA_SPACE=" "
[[ "$LAST_NODE" ]] && echo " </sdk:$LAST_NODE>" >> "$OUT"
LAST_NODE="$NODE"
[[ "$NODE" ]] && echo " <sdk:$NODE>" >> "$OUT"
fi
if needs_full_revision "$ELEMENT" "$KEY" ${FULL_REVISIONS[@]}; then
echo "$EXTRA_SPACE <sdk:$KEY>" >> "$OUT"
write_full_revision "$VALUE" "$EXTRA_SPACE" >> "$OUT"
echo "$EXTRA_SPACE </sdk:$KEY>" >> "$OUT"
else
echo "$EXTRA_SPACE <sdk:$KEY>$VALUE</sdk:$KEY>" >> "$OUT"
fi
shift
shift
done
if [[ "$LAST_NODE" ]]; then echo " </sdk:$LAST_NODE>" >> "$OUT"; fi
}
while [[ -n "$1" ]]; do
# Process archives.
# First we expect a type. For convenience the type can be plural.
TYPE=$(check_enum "${1%%s}" $TYPES)
[[ -z $TYPE ]] && error "Unknown archive type '$1'."
shift
ELEMENT="$TYPE"
MAP=""
FIRST="1"
LIBS_XML=""
OS=$(check_enum "$1" $OSES)
while [[ $OS ]]; do
shift
[[ $OS == "linux-x86" ]] && OS=linux
[[ $OS == "darwin" ]] && OS=macosx
SRC="$1"
DST="$1"
if [[ "${SRC/:/}" != "$SRC" ]]; then
DST="${SRC/*:/}"
SRC="${SRC/:*/}"
fi
[[ ! -f "$SRC" ]] && error "Missing file for archive $TYPE/$OS: $SRC"
shift
# Depending on the archive type, we need a number of attributes
# from the source.properties or the manifest.ini. We'll take
# these attributes from the first zip found.
#
# What we need vs. which package uses it:
# - description all
# - revision all
# - version platform
# - included-abi platform
# - api-level platform sample doc add-on system-image
# - codename platform sample doc add-on system-image
# - min-tools-rev platform sample
# - min-platform-tools-rev tool
# - min-api-level extra
# - vendor extra add-on
# - path extra
# - old-paths extra
# - abi system-image
#
# We don't actually validate here.
# Just take whatever is defined and put it in the XML.
# XML validation against the schema will be done at the end.
if [[ $FIRST ]]; then
FIRST=""
if unzip -t "$SRC" | grep -qs "source.properties" ; then
# Extract Source Properties
# unzip: -j=flat (no dirs), -q=quiet, -o=overwrite, -d=dest dir
unzip -j -q -o -d "$TMP_DIR" "$SRC" "*/source.properties"
PROPS="$TMP_DIR/source.properties"
elif unzip -t "$SRC" | grep -qs "manifest.ini" ; then
unzip -j -q -o -d "$TMP_DIR" "$SRC" "*/manifest.ini"
PROPS="$TMP_DIR/manifest.ini"
# Parse the libs for an addon and generate the <libs> node
# libraries is a semi-colon separated list
LIBS=$(parse_attributes "$PROPS" "libraries")
LIBS_XML=" <sdk:libs>"
for LIB in ${LIBS//;/ }; do
LIBS_XML="$LIBS_XML
<sdk:lib><sdk:name>$LIB</sdk:name></sdk:lib>"
done
LIBS_XML="$LIBS_XML
</sdk:libs>"
else
error "Failed to find source.properties or manifest.ini in $SRC"
fi
[[ ! -f $PROPS ]] && error "Failed to extract $PROPS from $SRC"
MAP=$(parse_attributes "$PROPS" ${ATTRS[@]})
# Time to generate the XML for the package
echo " <sdk:${ELEMENT}>" >> "$OUT"
output_attributes "$ELEMENT" "$OUT" $MAP
[[ -n "$LIBS_XML" ]] && echo "$LIBS_XML" >> "$OUT"
echo " <sdk:archives>" >> "$OUT"
fi
# Generate archive info
#echo "## Add $TYPE/$OS archive $SRC"
if [[ $( uname ) == "Darwin" ]]; then
SIZE=$( stat -f %z "$SRC" )
else
SIZE=$( stat -c %s "$SRC" )
fi
SHA1=$( sha1sum "$SRC" | cut -d " " -f 1 )
if uses_new_host_os ; then
USE_HOST_OS=1
else
OLD_OS_ATTR=" os='$OS'"
fi
cat >> "$OUT" <<EOFA
<sdk:archive$OLD_OS_ATTR>
<sdk:size>$SIZE</sdk:size>
<sdk:checksum type='sha1'>$SHA1</sdk:checksum>
<sdk:url>$DST</sdk:url>
EOFA
if [[ $USE_HOST_OS ]]; then
# parse the Archive.Host/Jvm info from the source.props if present
MAP=$(parse_attributes "$PROPS" ${ATTRS_ARCHIVE[@]})
# Always generate host-os if not present
if [[ "${MAP/ host-os /}" == "$MAP" ]]; then
MAP="$MAP host-os $OS"
fi
output_attributes "archive" "$OUT" $MAP
fi
echo " </sdk:archive>" >> "$OUT"
# Skip to next arch/zip entry.
# If not a valid OS, close the archives/package nodes.
OS=$(check_enum "$1" $OSES)
if [[ ! "$OS" ]]; then
echo " </sdk:archives>" >> "$OUT"
echo " </sdk:${ELEMENT}>" >> "$OUT"
fi
done
done
# Generate XML footer
echo "</sdk:$ROOT>" >> "$OUT"
#echo "## Validate XML against schema"
$XMLLINT --noout --schema $SCHEMA "$OUT"
Reference in New Issue View Git Blame Copy Permalink