cd -P "${1%/*}"

local file="$PWD/${1##*/}"

while [[ -h "$file" ]]; do

# On Mac OS, readlink -f doesn't work.

cd -P "${file%/*}"

file="$(readlink "$file")"

cd -P "${file%/*}"

file="$PWD/${file##*/}"

done

echo "$PWD/${file##*/}"

mkdir -p "$FLUTTER_ROOT/bin/cache"

# This function is executed with a redirect that pipes the source of

# this script into file descriptor 3.

#

# To ensure that we don't simultaneously update Dart in multiple

# parallel instances, we try to obtain an exclusive lock on this

# file descriptor (and thus this script's source file) while we are

# updating Dart and compiling the script. To do this, we try to use

# the command line program "flock", which is available on many

# Unix-like platforms, in particular on most Linux distributions.

# You give it a file descriptor, and it locks the corresponding

# file, having inherited the file descriptor from the shell.

#

# Complicating matters, there are two major scenarios where this

# will not work.

#

# The first is if the platform doesn't have "flock", for example on Mac.

# There is not a direct equivalent, so on platforms that don't have flock,

# we fall back to using a lockfile and spinlock with "shlock". This

# doesn't work as well over NFS as it relies on PIDs. Any platform

# without either of these tools has no locking at all. To determine if we

# have "flock" or "shlock" available, we abuse the "hash" shell built-in.

#

# The second complication is NFS. On NFS, to obtain an exclusive

# lock you need a file descriptor that is open for writing, because

# NFS implements exclusive locks by writing, or some such. Thus, we

# ignore errors from flock. We do so by using the '|| true' trick,

# since we are running in a 'set -e' environment wherein all errors

# are fatal, and by redirecting all output to /dev/null, since

# users will typically not care about errors from flock and are

# more likely to be confused by them than helped.

#

# For "flock", the lock is released when the file descriptor goes out of

# scope, i.e. when this function returns. The lock is released via

# a trap when using "shlock".

if hash flock 2>/dev/null; then

flock 3 2>/dev/null || true

elif hash shlock 2>/dev/null; then

FLUTTER_UPGRADE_LOCK="$FLUTTER_ROOT/bin/cache/.upgrade_lock"

while ! shlock -f "$FLUTTER_UPGRADE_LOCK" -p $$ ; do sleep .1 ; done

trap _rmlock EXIT

fi

local revision="$(cd "$FLUTTER_ROOT"; git rev-parse HEAD)"

if [[ ! -f "$SNAPSHOT_PATH" ]] || [[ ! -s "$STAMP_PATH" ]] || [[ "$(cat "$STAMP_PATH")" != "$revision" ]] || [[ "$FLUTTER_TOOLS_DIR/pubspec.yaml" -nt "$FLUTTER_TOOLS_DIR/pubspec.lock" ]]; then

rm -f "$FLUTTER_ROOT/version"

touch "$FLUTTER_ROOT/bin/cache/.dartignore"

"$FLUTTER_ROOT/bin/internal/update_dart_sdk.sh"

echo Building flutter tool...

if [[ "$TRAVIS" == "true" ]] || [[ "$BOT" == "true" ]] || [[ "$CONTINUOUS_INTEGRATION" == "true" ]] || [[ "$CHROME_HEADLESS" == "1" ]] || [[ "$APPVEYOR" == "true" ]] || [[ "$CI" == "true" ]]; then

PUB_ENVIRONMENT="$PUB_ENVIRONMENT:flutter_bot"

fi

export PUB_ENVIRONMENT="$PUB_ENVIRONMENT:flutter_install"

if [[ -d "$FLUTTER_ROOT/.pub-cache" ]]; then

export PUB_CACHE="${PUB_CACHE:-"$FLUTTER_ROOT/.pub-cache"}"

fi

while : ; do

cd "$FLUTTER_TOOLS_DIR"

"$PUB" upgrade --verbosity=error --no-packages-dir && break

echo Error: Unable to 'pub upgrade' flutter tool. Retrying in five seconds...

sleep 5

done

"$DART" --snapshot="$SNAPSHOT_PATH" --packages="$FLUTTER_TOOLS_DIR/.packages" "$SCRIPT_PATH"

echo "$revision" > "$STAMP_PATH"

fi

# The exit here is duplicitous since the function is run in a subshell,

# but this serves as documentation that running the function in a

# subshell is required to make sure any lockfile created by shlock

# is cleaned up.

exit $?