env.sh

# Copyright 2016 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

#
# Source this script into BASH or ZSH to include various useful functions
# in your environment.
#
#   $ source path/to/fuchsia/scripts/env.sh
#   $ envprompt
#   $ fgo
#   $ fset x86-64
#   $ fbuild
#
# Functions prefixed with 'f' are for fuchsia.
# Functions prefixed with 'z' are for zircon.
#

if [[ -n "${ZSH_VERSION}" ]]; then
  export FUCHSIA_SCRIPTS_DIR=${${(%):-%x}:a:h}
else
  export FUCHSIA_SCRIPTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
fi

export FUCHSIA_DIR="$(dirname "${FUCHSIA_SCRIPTS_DIR}")"
export FUCHSIA_OUT_DIR="${FUCHSIA_DIR}/out"

FUCHSIA_ENV_SH_VERSION="$(git --git-dir=${FUCHSIA_SCRIPTS_DIR}/.git rev-parse HEAD)"

source "${FUCHSIA_DIR}/scripts/devshell/env.sh"

function __netaddr() {
  # We want to give the user time to accept Darwin's firewall dialog.
  if [[ "$(uname -s)" = "Darwin" ]]; then
    netaddr "$@"
  else
    netaddr --nowait "$@"
  fi
}

### envhelp: print usage for command or list of commands

function env_sh_version() {
  echo $FUCHSIA_ENV_SH_VERSION
}

function envhelp() {
  if [[ $# -ne 1 ]]; then
    # note: please keep these sorted
    cat <<END
env.sh functions:
  envhelp, env_sh_version
zircon functions:
  zboot, zbuild, zcheck, zgo, zrun, zset, zsymbolize
fuchsia functions:
  fboot, fbuild, fbuild-sysroot, fcheck, fcmd, fcp, fgen,
  fgen-if-changed, fgo, finstall, freboot, frun, fset, fsymbolize
END
    return
  fi
  $1-usage
}

### envprompt: embed information about the build environment in the shell prompt

function envprompt-info() {
  if ! [[ -z "${ENVPROMPT_INFO}" ]]; then
    echo "[${ENVPROMPT_INFO}] "
  fi
}

function envprompt() {
  if [[ -n "${ZSH_VERSION}" ]]; then
    autoload -Uz colors && colors
    setopt PROMPT_SUBST
    export PS1='%B%F{yellow}$(envprompt-info)%B%F{blue}%m:%~%#%f%b '
    export PS2='%B%F{blue}>%f%b '
  else
    export PS1='\[\e[0;1;33m\]$(envprompt-info)\[\e[34m\]\h:\w\\$\[\e[0m\] '
    export PS2='\[\e[0;1;34m\]>\[\e[0m\] '
  fi
}

### zgo: navigate to directory within zircon

function zgo-usage() {
  cat >&2 <<END
Usage: zgo [dir]
Navigates to directory within zircon.
END
}

function zgo() {
  if [[ $# -gt 1 ]]; then
    zgo-usage
    return 1
  fi

  cd "${FUCHSIA_DIR}/zircon/$1"
}

if [[ -z "${ZSH_VERSION}" ]]; then
  function _zgo() {
    local cur
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    COMPREPLY=($(ls -dp1 --color=never ${FUCHSIA_DIR}/zircon/${cur}* 2>/dev/null | \
      sed -n "s|^${FUCHSIA_DIR}/zircon/\(.*/\)\$|\1|p" | xargs echo))
  }
  complete -o nospace -F _zgo zgo
fi

### zcheck: checks whether zset was run

function zcheck-usage() {
  cat >&2 <<END
Usage: zcheck
Checks whether zircon build options have been set.
END
}

function zcheck() {
  if [[ -z "${ZIRCON_SETTINGS}" ]]; then
    echo "Must run zset first (see envhelp for more)." >&2
    return 1
  fi
  return 0
}

### zbuild: build zircon

function zbuild-usage() {
  cat >&2 <<END
Usage: zbuild [extra make args...]
Builds zircon.
END
}

function zbuild() {
  zcheck || return 1

  echo "Building zircon..." \
    && "${FUCHSIA_SCRIPTS_DIR}/build-zircon.sh" \
         -t "${ZIRCON_BUILD_TARGET}" "$@"
}

function zbuild-if-changed() {
  echo "Deprecated - just run zbuild"
  zbuild
}

### zboot: run zircon bootserver

function zboot-usage() {
  cat >&2 <<END
Usage: zboot [extra bootserver args...]
Runs zircon system bootserver.
END
}

function zboot() {
  zcheck || return 1

  "${FUCHSIA_OUT_DIR}/build-zircon/tools/bootserver" "${ZIRCON_BUILD_DIR}/zircon.bin" "$@"
}

### zrun: run zircon in qemu

function zrun-usage() {
  cat >&2 <<END
Usage: zrun [extra qemu args...]
Runs zircon system in qemu.
END
}

function zrun() {
  zcheck || return 1

  local qemu_dir="${QEMU_DIR:-$(source "${FUCHSIA_DIR}/buildtools/vars.sh" && echo -n ${BUILDTOOLS_QEMU_DIR})/bin}"

  "${FUCHSIA_DIR}/zircon/scripts/run-zircon" -o "${ZIRCON_BUILD_DIR}" -a "${ZIRCON_ARCH}" \
    -q "${qemu_dir}" "$@"
}

### zsymbolize: symbolizes stack traces

function zsymbolize-usage() {
  cat >&2 <<END
Usage: zsymbolize [extra symbolize args...]
Symbolizes stack trace from standard input.
END
}

function zsymbolize() {
  zcheck || return 1

  # TODO(jeffbrown): Fix symbolize to support arch other than x86-64
  "${FUCHSIA_DIR}/zircon/scripts/symbolize" --build-dir "${ZIRCON_BUILD_DIR}" "$@"
}

### zlog: run zircon log listener

function zlog-usage() {
  cat >&2 <<END
Usage: zlog [extra log listener args...]
Runs zircon log listener.
END
}

function zlog() {
  zcheck || return 1

  "${FUCHSIA_OUT_DIR}/build-zircon/tools/loglistener" "$@"
}


### fgo: navigate to directory within fuchsia

function fgo-usage() {
  cat >&2 <<END
Usage: fgo [dir]
Navigates to directory within fuchsia root.
END
}

function fgo() {
  if [[ $# -gt 1 ]]; then
    fgo-usage
    return 1
  fi

  cd "${FUCHSIA_DIR}/$1"
}

if [[ -z "${ZSH_VERSION}" ]]; then
  function _fgo() {
    local cur
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    COMPREPLY=($(/bin/ls -dp1 ${FUCHSIA_DIR}/${cur}* 2>/dev/null | \
      sed -n "s|^${FUCHSIA_DIR}/\(.*/\)\$|\1|p" | xargs echo))
  }
  complete -o nospace -F _fgo fgo
fi

### fset: set fuchsia build properties

function fset-usage() {
  # Note: if updating the syntax here please update zsh-completion/_fset to match
  cat >&2 <<END
Usage: fset x86-64|arm64|rpi3|odroidc2|hikey960
                              [--release] [--packages p1,p2...]
                              [--goma|--no-goma] [--no-ensure-goma]
                              [--goma-dir path]
                              [--ccache|--no-ccache]
                              [--dart-analysis]
Sets fuchsia build options.
END
}

function fset-add-gen-arg() {
  export FUCHSIA_GEN_ARGS="${FUCHSIA_GEN_ARGS} $*"
}

function fset-add-ninja-arg() {
  export FUCHSIA_NINJA_ARGS="${FUCHSIA_NINJA_ARGS} $*"
}

function fset() {
  if [[ $# -lt 1 ]]; then
    fset-usage
    return 1
  fi

  local settings="$*"
  export FUCHSIA_GEN_ARGS=
  export FUCHSIA_NINJA_ARGS=
  export FUCHSIA_VARIANT=debug

  case $1 in
    x86-64)
      zset x86-64
      # TODO(jeffbrown): we should really align these
      export FUCHSIA_GEN_TARGET=x86-64
      ;;
    arm64|rpi3|odroidc2|hikey960)
      zset $1
      export FUCHSIA_GEN_TARGET=aarch64
      ;;
    *)
      fset-usage
      return 1
  esac
  fset-add-gen-arg --target_cpu "${FUCHSIA_GEN_TARGET}"
  shift

  local goma
  local goma_dir
  local ensure_goma=1
  local ccache
  local dart_analysis=0
  while [[ $# -ne 0 ]]; do
    case $1 in
      --release)
        fset-add-gen-arg --release
        export FUCHSIA_VARIANT=release
        ;;
      --packages)
        if [[ $# -lt 2 ]]; then
          fset-usage
          return 1
        fi
        fset-add-gen-arg --packages $2
        shift
        ;;
      --goma)
        goma=1
        ;;
      --no-goma)
        goma=0
        ;;
      --no-ensure-goma)
        ensure_goma=0
        ;;
      --goma-dir)
        if [[ $# -lt 2 ]]; then
          fset-usage
          return 1
        fi
        goma_dir=$2
        if [[ ! -d "${goma_dir}" ]]; then
          echo -e "GOMA directory does not exist: "${goma_dir}""
          return 1
        fi
        shift
        ;;
      --ccache)
        ccache=1
        ;;
      --no-ccache)
        ccache=0
        ;;
      --dart-analysis)
        dart_analysis=1
        ;;
      *)
        fset-usage
        return 1
    esac
    shift
  done

  export FUCHSIA_BUILD_DIR="${FUCHSIA_OUT_DIR}/${FUCHSIA_VARIANT}-${FUCHSIA_GEN_TARGET}"
  export FUCHSIA_BUILD_NINJA="${FUCHSIA_BUILD_DIR}/build.ninja"
  export FUCHSIA_GEN_ARGS_CACHE="${FUCHSIA_BUILD_DIR}/build.gen-args"
  export FUCHSIA_SETTINGS="${settings}"
  export FUCHSIA_ENSURE_GOMA="${ensure_goma}"
  export GOPATH="${FUCHSIA_BUILD_DIR}:${FUCHSIA_DIR}/garnet/go"

  # If a goma directory wasn't specified explicitly then default to "~/goma".
  if [[ -n "${goma_dir}" ]]; then
    export FUCHSIA_GOMA_DIR="${goma_dir}"
  else
    export FUCHSIA_GOMA_DIR=~/goma
  fi

  fset-add-ninja-arg -C "${FUCHSIA_BUILD_DIR}"

  # Automatically detect goma and ccache if not specified explicitly.
  if [[ -z "${goma}" ]] && [[ -z "${ccache}" ]]; then
    if [[ -d "${FUCHSIA_GOMA_DIR}" ]]; then
      goma=1
    elif [[ -n "${CCACHE_DIR}" ]] && [[ -d "${CCACHE_DIR}" ]]; then
      ccache=1
    fi
  fi

  # Add --goma or --ccache as appropriate.
  local builder=
  if [[ "${goma}" -eq 1 ]]; then
    fset-add-gen-arg --goma "${FUCHSIA_GOMA_DIR}"
    # macOS needs a lower value of -j parameter, because it has a limit on the
    # number of open file descriptors. Use 4 * cpu_count, which works well in
    # practice.
    if [[ "$(uname -s)" = "Darwin" ]]; then
      numjobs=$(( $(sysctl -n hw.ncpu) * 4 ))
      fset-add-ninja-arg -j ${numjobs}
    else
      fset-add-ninja-arg -j 1000
    fi
    builder="-goma"
  elif [[ "${ccache}" -eq 1 ]]; then
    fset-add-gen-arg --ccache
    builder="-ccache"
  fi

  if [[ "${dart_analysis}" -eq 1 ]]; then
    fset-add-gen-arg --with-dart-analysis
  fi

  export ENVPROMPT_INFO="${ENVPROMPT_INFO}-${FUCHSIA_VARIANT}${builder}"
}

### fcheck: checks whether fset was run

function fcheck-usage() {
  cat >&2 <<END
Usage: fcheck
Checks whether fuchsia build options have been set.
END
}

function fcheck() {
  if [[ -z "${FUCHSIA_SETTINGS}" ]]; then
    echo "Must run fset first (see envhelp for more)." >&2
    return 1
  fi
  return 0
}

### fgen: generate ninja build files

function fgen-usage() {
  cat >&2 <<END
Usage: fgen [extra gen.py args...]
Generates ninja build files for fuchsia.
END
}

function fgen-internal() {
  if [[ -n "${ZSH_VERSION}" ]]; then
    "${FUCHSIA_DIR}/packages/gn/gen.py" ${=FUCHSIA_GEN_ARGS} "$@"
  else
    "${FUCHSIA_DIR}/packages/gn/gen.py" ${FUCHSIA_GEN_ARGS} "$@"
  fi
}

function fgen() {
  fcheck || return 1

  echo "Generating ninja files..."
  rm -f "${FUCHSIA_GEN_ARGS_CACHE}"
  zbuild \
    && fgen-internal "$@" \
    && (echo "${FUCHSIA_GEN_ARGS}" > "${FUCHSIA_GEN_ARGS_CACHE}")
}

### fgen-if-changed: only generate ninja build files if stale

function fgen-if-changed-usage() {
  cat >&2 <<END
Usage: fgen-if-changed [extra gen.py args...]
Generates ninja build files for fuchsia only if gen args have changed.
END
}

function fgen-if-changed() {
  fcheck || return 1

  local last_gen_args
  if [[ -f "${FUCHSIA_GEN_ARGS_CACHE}" ]]; then
    last_gen_args=$(cat "${FUCHSIA_GEN_ARGS_CACHE}")
  fi

  if ! ([[ -f "${FUCHSIA_BUILD_NINJA}" ]] \
      && [[ "${FUCHSIA_GEN_ARGS}" == "${last_gen_args}" ]]); then
    fgen "$@"
  fi
}

### fsysroot: build sysroot

function fbuild-sysroot() {
  echo "Deprecated - just run fbuild"
  zbuild
}

function fbuild-sysroot-if-changed() {
  echo "Deprecated - just run zbuild"
  zbuild
}

### fbuild: build fuchsia

function fbuild-usage() {
  cat >&2 <<END
Usage: fbuild [extra ninja args...]
Builds fuchsia.
END
}

function fbuild-goma-ensure-start() {
  if ([[ "${FUCHSIA_GEN_ARGS}" == *--goma* ]] \
      && [[ "${FUCHSIA_ENSURE_GOMA}" -eq 1 ]]); then
    "${FUCHSIA_GOMA_DIR}"/goma_ctl.py ensure_start
  fi
}

function fbuild-internal() {
  if [[ -n "${ZSH_VERSION}" ]]; then
    "${FUCHSIA_DIR}/buildtools/ninja" ${=FUCHSIA_NINJA_ARGS} "$@"
  else
    "${FUCHSIA_DIR}/buildtools/ninja" ${FUCHSIA_NINJA_ARGS} "$@"
  fi
}

function fbuild() {
  fcheck || return 1

  zbuild \
    && fgen-if-changed \
    && fbuild-goma-ensure-start \
    && echo "Building fuchsia..." \
    && fbuild-internal "$@"
}

function __fbuild_make_batch() {
  # parse a bootfs manifest, compare inputs to a stamp file and append
  # sftp commands to a batch file to update changed files.
  local manifest stamp batch_file userfs_path build_path
  manifest=$1
  stamp=$2
  batch_file=$3

  while IFS=\= read userfs_path build_path; do
    if [[ -z "${build_path}" ]]; then
      continue
    fi

    if [[ $build_path -nt $stamp ]]; then
      local device_path=/system/${userfs_path}
      echo "Updating ${device_path} with ${build_path}"
      echo "-rm ${device_path}" >> "$batch_file"
      echo "put ${build_path} ${device_path}" >> "$batch_file"
    fi
  done < "$manifest"
}

function fbuild-sync() {
  local stamp status_file batch_file package host

  stamp="${FUCHSIA_BUILD_DIR}/.fbuild-sync-stamp"
  status_file="${FUCHSIA_BUILD_DIR}/.fbuild-sync-status"
  batch_file="${FUCHSIA_BUILD_DIR}/.fbuild-sync-batchfile"

  touch "$status_file"
  if [[ "$(cat $status_file)" != "failed" ]]; then
    touch $stamp
  fi

  fbuild $*

  if [ $? -ne 0 ]; then
    echo failed > $status_file
    return 1
  fi

  echo -n > "$batch_file"

  __fbuild_make_batch \
    "${FUCHSIA_BUILD_DIR}/gen/packages/gn/system.bootfs.manifest" \
    "$stamp" "$batch_file"

  while read package; do
    __fbuild_make_batch \
      "${FUCHSIA_BUILD_DIR}/package/$package/system_manifest" \
      "$stamp" "$batch_file"
  done < ${FUCHSIA_BUILD_DIR}/gen/packages/gn/packages

  echo "Syncing changed system.bootfs files..."
  host="$(__netaddr --fuchsia)"
  fsftp -q -b "${batch_file}" "[${host}]" > /dev/null
  if [ $? -ne 0 ]; then
    echo failed > "${status_file}"
    return 1
  fi

  rm -f "${stamp}"
  rm -f "${status_file}"
  rm -f "${batch_file}"
}

### fsyncvol: update a persistent fuchsia system

fsyncvol() {
  $FUCHSIA_SCRIPTS_DIR/make-fuchsia-vol/sync-fuchsia-vol.sh $@
}

### fboot: run fuchsia bootserver

function fboot-usage() {
  cat >&2 <<END
Usage: fboot [extra bootserver args...]
Runs fuchsia system bootserver.
END
}

function fboot() {
  fcheck || return 1

  zboot "${FUCHSIA_BUILD_DIR}/user.bootfs" "$@"
}

### finstall: build installer image and run boot server

function finstall-usage() {
  cat >&2 <<END
Usage: finstall [extra bootserver args...]
Builds installer image and runs fuchsia system bootserver with it.
END
}

function finstall() {
  fcheck || return 1

  "${FUCHSIA_SCRIPTS_DIR}/installer/build-installable-userfs.sh" \
      -b "${FUCHSIA_BUILD_DIR}" \
    && echo "After netbooting, please run 'install-fuchsia' on the device to complete the installation." \
    && zboot "${FUCHSIA_BUILD_DIR}/installer.bootfs" "$@"
}

### frun: run fuchsia in qemu

function frun-usage() {
  cat >&2 <<END
Usage: frun [extra qemu args...]
Runs fuchsia system in qemu.
END
}

function frun() {
  fcheck || return 1

  zrun -x "${FUCHSIA_BUILD_DIR}/user.bootfs" "$@"
}

### fbox: run fuchsia in virtualbox

function fbox() {
  fcheck || return 1

  "$FUCHSIA_SCRIPTS_DIR/vbox/fbox.sh" "$@"
}

### fsymbolize: symbolizes stack traces with fuchsia build

function fsymbolize-usage() {
  cat >&2 <<END
Usage: fsymbolize [extra symbolize args...]
Symbolizes stack trace from standard input.
END
}

function fsymbolize() {
  fcheck || return 1

  # TODO(jeffbrown): Fix symbolize to support arch other than x86-64
  "${FUCHSIA_DIR}/zircon/scripts/symbolize" \
      --build-dir "${ZIRCON_BUILD_DIR}" "${FUCHSIA_BUILD_DIR}" "$@"
}

### freboot: reboot the attached device

function freboot-usage() {
  cat >&2 <<END
Usage: freboot
Reboots the attached device.
END
}

function freboot() {
  if [[ $# -gt 1 ]]; then
      freboot_usage
      return 1
  fi

  # Add timeout for OS X users so they can click the network connection warning
  # dialog.
  local timeout_flag
  if [[ "$(uname -s)" = "Darwin" ]]; then
    timeout_flag="--timeout=3000"
  else
    timeout_flag="--nowait"
  fi

  freboot_host=${1:-":"}
  fcheck || return 1
  echo "Rebooting system..."
  netruncmd $timeout_flag "${freboot_host}" "dm reboot"
}

### fmkzedboot: builds the Fuchsia bootloader and zeboot and places it on an
### external drive

function fmkzedboot-usage() {
  cat >&2 <<END
Usage: fmkzedboot <root of external drive>
Builds Fuchsia bootloader and zedboot and copies it to a drive of
your choice. Makes zedboot the default boot option.
END
}

function fmkzedboot() {
  if [[ $# -ne 1 ]]; then
    fmkzedboot-usage
    return 1
  fi

  fcheck || return 1

  if [[ ! -d $1 ]]; then
    echo >&2 "Drive at $1 does not appear to be mounted."
    return 1
  fi

  local DRIVE_DIR=$1
  local EFI_TARGET_DIR=$1/EFI/BOOT
  (
    set -e

    # Do a zircon build, and copy the bootloader to drive
    zbuild
    mkdir -p ${EFI_TARGET_DIR}
    cp ${ZIRCON_BUILD_DIR}/bootloader/bootx64.efi \
      ${EFI_TARGET_DIR}/BOOTX64.EFI

    # Make zedboot
    echo "netsvc.netboot=true virtcon.font=18x32" > ${ZIRCON_BUILD_DIR}/CMDLINE
    ${ZIRCON_BUILD_DIR}/tools/mkbootfs -o ${ZIRCON_BUILD_DIR}/zedboot.bin \
      ${ZIRCON_BUILD_DIR}/zircon.bin                                   \
      -C ${ZIRCON_BUILD_DIR}/CMDLINE ${ZIRCON_BUILD_DIR}/bootdata.bin

    # Copy zedboot.bin to drive
    cp ${ZIRCON_BUILD_DIR}/zedboot.bin ${DRIVE_DIR}

    # Set zedboot as the default boot option, with a timeout of 0
    # (i.e. boot instantly into zedboot)
    echo "bootloader.default=zedboot bootloader.timeout=0" > ${ZIRCON_BUILD_DIR}/CMDLINE
    cp ${ZIRCON_BUILD_DIR}/CMDLINE ${DRIVE_DIR}
  ) && \
    echo "Bootloader + zedboot loaded to $1"
}


### fmkbootloader: builds the Fuchsia bootloader and places it on an external
### drive

function fmkbootloader-usage() {
  cat >&2 <<END
Usage: fmkbootloader <root of external drive>
Builds Fuchsia bootloader and copies it to a drive of your choice.
END
}

function fmkbootloader() {
  if [[ $# -ne 1 ]]; then
    fmkbootloader-usage
    return 1
  fi

  fcheck || return 1

  if [[ ! -d $1 ]]; then
    echo >&2 "Drive at $1 does not appear to be mounted."
    return 1
  fi

  local TARGET_DIR=$1/EFI/BOOT
  (
    set -e
    zbuild
    mkdir -p ${TARGET_DIR}
    cp ${ZIRCON_BUILD_DIR}/bootloader/bootx64.efi \
      ${TARGET_DIR}/BOOTX64.EFI
  ) && \
    echo "Bootloader loaded to $1"
}

go() {
  if [[ "$GOOS" == "fuchsia" ]]; then
    "${FUCHSIA_DIR}/buildtools/go" "$@"
  else
    # /usr/bin/which avoids cross-shell subtleties, exists on linux & osx.
    "$(/usr/bin/which go)" "$@"
  fi
}

function fssh() {
  SSH_AUTH_SOCK="" ssh -F $FUCHSIA_BUILD_DIR/ssh-keys/ssh_config $*
}

function fscp() {
  SSH_AUTH_SOCK="" scp -F $FUCHSIA_BUILD_DIR/ssh-keys/ssh_config $*
}

function fsftp() {
  SSH_AUTH_SOCK="" sftp -F $FUCHSIA_BUILD_DIR/ssh-keys/ssh_config $*
}

function fcmd() {
  local host="$(__netaddr --fuchsia)"
  fssh -q "${host}" $*
  local r=$?
  if [ $r -ne 0 ]; then
    echo "fssh exited with a non-zero status."
  fi
  return $r
}

function fcp-usage() {
  cat >&2 <<END
Usage: fcp src dst
Copies a file from the host to the target device.
END
}

function fcp() {
  if [[ $# -ne 2 ]]; then
    fcp-usage
    return 1
  fi

  local src=$1
  local dst=$2
  local host="$(__netaddr --fuchsia)"

  fsftp -q -b - "[${host}]" > /dev/null << EOF
- rm ${dst}
put ${src} ${dst}
EOF
}

function ftest-usage() {
  cat >&2 <<END
Usage: ftest target <args>
Builds the specified target (e.g., ftl_unittests), copies it to the target, and
executes it. Useful for tight iterations on unittests.
END
}

function ftest() {
  if [[ $# -eq 0 ]]; then
    ftest-usage
    return 1
  fi
  local target="$1"

  fbuild-internal "${target}"
  if [[ $? -ne 0 ]]; then
    return 1
  fi
  fcp "${FUCHSIA_BUILD_DIR}/${target}" "/tmp/${target}"
  shift
  fcmd "/tmp/${target}" $*
}

function fclock() {
  local device_date
  if [[ "$(uname -s)" = "Darwin" ]]; then
    device_date=`date +%Y-%m-%dT%T`
  else
    device_date=`date -Iseconds`
  fi

  echo "Setting device's clock to ${device_date}"
  fcmd "clock --set ${device_date}"
}

function fpublish-usage() {
  cat >&2 <<END
fpublish [--build-dir <DIR>] [--far-key <key file>] [--far-dir <DIR>] [--update-repo <DIR>] [pkg]
Publish packages. If no package name is supplied, all packages from the current
build output will be published.
  --build-dir
    Directory containing the build output
  --far-key
    Key used to sign the package's meta FAR
  --far-dir
    Directory to be used to build the meta FAR
  --update-repo
    Directory to be used to publish the meta FAR and associated content blobs
END
}

# Create a package manager package and then create update files which are
# published to the local file system. If no package name is supplied, all
# built packages are processed.
function fpublish() {
  local build_dir="${FUCHSIA_BUILD_DIR}"
  c=1
  while ((c<=$#)); do
    if [[ "${!c}" == "--build-dir" ]]; then
      c=$((c + 1))
      build_dir=${!c}
      break
    fi
    c=$((c + 1))
  done

  if [[ -z $build_dir ]]; then
    echo "Build directory is not set!"
    return -1
  fi

  # if an even number of args, assume no pkg name provided
  if [[ "$# % 2" -eq 0 ]]; then
    local pkgs_file="${build_dir}/gen/packages/gn/packages"
    local pkg_count=0
    local pkgs=()
    while IFS= read -r e || [[ -n "$e" ]]; do
      pkg_count=$(($pkg_count + 1))
      pkgs+=($e)
    done < "$pkgs_file"

    local i=1
    for e in "${pkgs[@]}"; do
      echo "Publishing ${i}/${pkg_count}: ${e}"
      fpublish-one "${@:1}" "$e"
      if [[ "$?" -ne 0 ]]; then
        fpublish-usage
        return $?
      fi
      i=$(($i + 1))
    done
  else
    fpublish-one "${@:1}"
      if [[ "$?" -ne 0 ]]; then
        fpublish-usage
        return $?
      fi
  fi
}

# See comments for fpublish, this does the same thing, but for an individual
# package.
function fpublish-one() {
  fcheck || return 1
  local pkg_name
  for pkg_name; do : ; done;
  local build_dir="${FUCHSIA_BUILD_DIR}"
  local stg_dir
  local update_repo

  local key_path
  local gen_key=1
  while (( "$#" )); do
    case $1 in
      "--update-repo")
        shift
        update_repo=$1
        ;;
      "--far-dir")
        shift
        stg_dir=$1
        ;;
      "--far-key")
        shift
        key_path=$1
        gen_key=0
        ;;
      "--build-dir")
        shift
        build_dir=$1
        ;;
    esac
    shift
  done

  if [[ -z $stg_dir ]]; then
    stg_dir="${build_dir}/fars/${pkg_name}"
  fi

  if [[ -z $update_repo ]]; then
    local update_repo="${build_dir}/amber-files"
  fi

  local arch_dir="${stg_dir}/archive"
  if [[ "$key_path" == "" ]]; then
    key_path="${stg_dir}/key"
  fi

  rm -r "${stg_dir}"/*  >/dev/null 2>&1
  mkdir -p "${arch_dir}"

  local pm_cmd="${build_dir}/host_x64/pm"
  local amber_cmd="${build_dir}/host_x64/amber-publish"
  local mani_path=""
  for try_path in ${build_dir}/package/${pkg_name}/{boot,system}_manifest; do
    if [[ -s  "$try_path" ]]; then
      mani_path="$try_path"
    fi
  done

  if [[ "$mani_path" == "" ]]; then
    echo "WARNING: manifest not found for ${pkg_name}, no package published."
    return 0
  fi

  if [[ "$gen_key" -eq 1 ]]; then
    "${pm_cmd}" "-o" "${arch_dir}" "-k" "${key_path}" "genkey" || return $?
  fi

  "${pm_cmd}" "-o" "${arch_dir}" "-n" "${pkg_name}" "init" || return $?

  "${pm_cmd}" "-o" "${arch_dir}" "-k" "${key_path}" "-m" "$mani_path" "build" || return $?

  "${amber_cmd}" "-r" "${update_repo}" "-p" "-f" "${arch_dir}/meta.far" "-n" "${pkg_name}.far" || return $?

  "${amber_cmd}" "-r" "${update_repo}" "-m" "-f" "${mani_path}" >/dev/null || return $?
}

if [[ -n "${ZSH_VERSION}" ]]; then
  ### Zsh Completion
  if [[ ${fpath[(Ie)${FUCHSIA_SCRIPTS_DIR}/zsh-completion]} -eq 0 ]]; then
    # if the fuchsia zsh completion dir isn't in the fpath yet...
    # add zsh completion function dir to the fpath
    fpath=(${FUCHSIA_SCRIPTS_DIR}/zsh-completion $fpath[@])
    # load and run compinit
    autoload -U compinit
    compinit
  fi
fi

alias gce="$FUCHSIA_SCRIPTS_DIR/gce/gce"