Blob Blame Raw
#!/bin/bash

usage() {
cat >&2 << EOF_USAGE
Usage: $0 -g <go import path> [-p <prefix>] [-G <go path>] [-v <version string>] [-a <attributes>]
<go import path>   the Go import path of the target package
<prefix>:          an eventual prefix path such as %{buildroot}
<go path>:         the root of the Go source tree
<version string>:  tag the provides with the <version string>
<attributes>:      attributes to add to the provides, for example
                   (commit=XXXX)(branch=YYYY) or
                   (vermod=alpha1)

Example:
echo filename | $0 -g golang.org/x/net -G /usr/share/gocode -v 2.5-0.1
echo filename | $0 -g golang.org/x/net -a '(commit=XXXX)(branch=YYYY)'
echo filename | $0 -g golang.org/x/net -a '(vermod=alpha1)'
EOF_USAGE
exit 1
}

if ! options=$(getopt -n $0 -o hg:p:G:v:a: -l help,goipath:,prefix:,gopath:,version:,attr:,attribute:,attributes: -- "$@")
then
    # something went wrong, getopt will put out an error message for us
    exit 2
fi

eval set -- "$options"

# Convert paths within gopath to version-constrained provides
# Never call it before checking the path belongs to the package import path
provides() {
  local ppath="$1"
  # Check for a vendor root, when not processing a symlink
  if ! ( [[ -L "${ppath}" ]] || ( notvendored "${ppath}" ) ) ; then
    local vroot="$(realpath -sm "${ppath}")/"
    vroot="${vroot%/vendor/*}/vendor"
    if [[ "${vroot}" != "${ppath}" ]] ; then
      # Check if a parent with files exists within the vendor root
      local tip="${ppath}"
      local vipath=/dev/null
      until [[ "${tip}" == "${vroot}" || "${ppath}" == "${vipath}/"* ]] ; do
        [[ -n $(find "$tip" -maxdepth 1 -type f) ]] && vipath="$tip"
        tip=$(dirname "$tip")
      done
      # If we didn't find a parent with files other than the path itself, it is
      # the vendored import path root!
      if [[ "$vipath" == "$ppath" ]] ; then
        echo "bundled(golang(${ppath##*/vendor/}))"
      fi
    fi
  else
    local package="${ppath#${root}/src/}"
    for index in "${!deco[@]}" ; do
      echo "golang(${package})${deco[index]}${version}"
    done
  fi
}

# Resolve a symlink target in presence of a build root
resolvelink() {
  local lt=$(realpath -m "$1")
  echo "${prefix}${lt#${prefix}}"
}

# Resolve a symlink to its ultimate target in presence of a build root
ultimateresolvelink() {
  local lt="$1"
  until [[ ! -L ${lt} ]] ; do
    lt=$(resolvelink "${lt}")
  done
  echo "${lt}"
}

# Test if a path is a directory within the package import path.
isgoipathdir() {
  local lt="$1"
  if [[ -d ${lt} ]] && [[ "${lt}"/ == "${root}/src/${goipath}"/* ]] ; then
    true
  else
    false
  fi
}

# Test if a path is vendored
notvendored() {
  local p=$(realpath -sm "$1")
  local vr="${p}/"
  vr="${vr%/vendor/*}"
  if [[ "${vr}" != "${p}/" ]] ; then
    false
  else
    true
  fi
}

# A symlink can point to a whole directory tree, but go.attr will only
# trigger on the root symlink.
# Therefore, check the symlink points within the processed import path, then
# walk all the target tree to generate symlink provides
#
# To process nested symlinks the function needs to be provided a working path
# to the symlink tip within the build root as second argument.
processlink() {
  local link="$1"
  local linktarget=$(ultimateresolvelink "$2")
  if ( isgoipathdir "${linktarget}" ) && ( notvendored "${linktarget}" ) ; then
    find "${linktarget}" -type d -print | while read subdir ; do
      provides    "${link}${subdir#${linktarget}}"
    done
    find "${linktarget}" -type l -print | while read sublink ; do
      processlink "${link}${sublink#${linktarget}}" "${sublink}"
    done
  fi
}

version=''
prefix=''
gopath=/usr/share/gocode
declare -A attributes

while [ $# -gt 0 ] ; do
  case $1 in
    -h|--help)    usage ;;
    -g|--goipath) goipath="$2" ; shift;;
    -p|--prefix)  prefix=$(realpath -sm "$2") ; shift;;
    -G|--gopath)  gopath="$2" ; shift;;
    -v|--version) version=" = $2" ; shift;;
    -a|--attr|--attribute|--attributes)
                  IFS=')' read -r -a newattrs <<< "$2"
                  for index in "${!newattrs[@]}" ; do
                    newattrs[index]=${newattrs[index]#\(}
                    attributes[${newattrs[index]%%=*}]=${newattrs[index]#*=}
                  done ; shift;;
    (--)          shift; break;;
    (-*)          echo "$0: error - unrecognized option $1" >&2; exit 3;;
    (*)           break;;
  esac
  shift
done

# Detection of the package import path root is necessary to insure we do not
# generate useless provides such as golang(github).
#
# When go dep stabilizes and can be generalized import path root detection may
# be automated by searching for the first level of go dep lock files.
#
# However the requirement to set %{goipath} may remain to make sure we avoid
# processing directories created without applying the sanity checks documented
# in Fedora Packaging Guidelines.
[[ -z ${goipath} ]] && exit 0

root="${prefix}${gopath}"

deco=( "" )
# Some filtering may be needed in the future
for key in "${!attributes[@]}"; do
  [ -n "${attributes[$key]}" ] && deco+=( "($key=${attributes[$key]})" )
done

# go.attr ensures that every time a package declares owning a directory or
# symlink under %{gopath}/src, the directory or symlink name will be piped to
# this script to compute the package Go provides.
#
# For legacy reason the script is supposed to be able to handle multiple
# inputs, even though modern rpm invokes it separately for each directory.
#
# As native Go tooling is focused on leaf developer needs (“what I need from
# others to build my code”, not “what I provide to help others build their
# code”) Go auto-provides do not invoke any Go binary and just record all the
# directories created under the import path root. This is actually faster and
# more reliable, since Go project seem to import pretty much any import path
# subdirectory, even if it contains assets without any .go file.
while read dir ; do
  if [[ -L $dir ]] ; then
    processlink "$dir" "$dir"
  else
    # If go.attr triggered on a normal directory just make sure it is under the
    # package import path, then provide it
    if [[ -d $dir ]] ; then
      dir=$(realpath -sm "$dir")
      [[ "${dir}"/ == "${root}/src/${goipath}"/* ]] && provides "$dir"
    fi
  fi
done | sort | uniq | grep -v '/\([._]\)\?\(internal\|vendor\)\([/)]\)'