class Sqoop < Formula
  desc "Transfer bulk data between Hadoop and structured datastores"
  homepage "https://sqoop.apache.org/"
  url "https://www.apache.org/dyn/closer.cgi?path=sqoop/1.4.6/sqoop-1.4.6.bin__hadoop-2.0.4-alpha.tar.gz"
  version "1.4.6"
  sha256 "d582e7968c24ff040365ec49764531cb76dfa22c38add5f57a16a57e70d5d496"

  bottle :unneeded

  depends_on :java => "1.6+"
  depends_on "hadoop"
  depends_on "hbase"
  depends_on "hive"
  depends_on "zookeeper"
  depends_on "coreutils"

  # Patch for readlink -f missing on OS X. Should be fixed in 1.4.7.
  # https://issues.apache.org/jira/browse/SQOOP-2531
  patch :DATA

  def sqoop_envs
    <<-EOS.undent
      export HADOOP_HOME="#{HOMEBREW_PREFIX}"
      export HBASE_HOME="#{HOMEBREW_PREFIX}"
      export HIVE_HOME="#{HOMEBREW_PREFIX}"
      export ZOOCFGDIR="#{etc}/zookeeper"
    EOS
  end

  def install
    libexec.install %w[bin conf lib]
    libexec.install Dir["*.jar"]

    bin.install Dir["#{libexec}/bin/*"]
    bin.env_script_all_files(libexec/"bin", Language::Java.java_home_env)

    # Install a sqoop-env.sh file
    envs = libexec/"conf/sqoop-env.sh"
    envs.write(sqoop_envs) unless envs.exist?
  end

  def caveats; <<-EOS.undent
    Hadoop, Hive, HBase and ZooKeeper must be installed and configured
    for Sqoop to work.
    EOS
  end

  test do
    assert_match /#{version}/, shell_output("#{bin}/sqoop version")
  end
end

__END__
diff --git a/bin/sqoop-codegen b/bin/sqoop-codegen
index 11a7ead..c24da32 100755
--- a/bin/sqoop-codegen
+++ b/bin/sqoop-codegen
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-create-hive-table b/bin/sqoop-create-hive-table
index 9380de4..316411a 100755
--- a/bin/sqoop-create-hive-table
+++ b/bin/sqoop-create-hive-table
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-eval b/bin/sqoop-eval
index a7b70c0..cc3f6a3 100755
--- a/bin/sqoop-eval
+++ b/bin/sqoop-eval
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-export b/bin/sqoop-export
index 3df45e3..4a3b3cf 100755
--- a/bin/sqoop-export
+++ b/bin/sqoop-export
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-help b/bin/sqoop-help
index ae4ee46..53ead16 100755
--- a/bin/sqoop-help
+++ b/bin/sqoop-help
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-import b/bin/sqoop-import
index d283395..21afee2 100755
--- a/bin/sqoop-import
+++ b/bin/sqoop-import
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-import-all-tables b/bin/sqoop-import-all-tables
index 8eb3fe4..4de0e31 100755
--- a/bin/sqoop-import-all-tables
+++ b/bin/sqoop-import-all-tables
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-import-mainframe b/bin/sqoop-import-mainframe
index 26a8c1e..ed74b84 100755
--- a/bin/sqoop-import-mainframe
+++ b/bin/sqoop-import-mainframe
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-job b/bin/sqoop-job
index 90d5772..fc817c3 100755
--- a/bin/sqoop-job
+++ b/bin/sqoop-job
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-list-databases b/bin/sqoop-list-databases
index 3428a3d..a373880 100755
--- a/bin/sqoop-list-databases
+++ b/bin/sqoop-list-databases
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-list-tables b/bin/sqoop-list-tables
index 393567c..0ab6849 100755
--- a/bin/sqoop-list-tables
+++ b/bin/sqoop-list-tables
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-merge b/bin/sqoop-merge
index e600e1f..e621917 100755
--- a/bin/sqoop-merge
+++ b/bin/sqoop-merge
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-metastore b/bin/sqoop-metastore
index 7c8a989..3448bcc 100755
--- a/bin/sqoop-metastore
+++ b/bin/sqoop-metastore
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`

diff --git a/bin/sqoop-version b/bin/sqoop-version
index d047309..db32c43 100755
--- a/bin/sqoop-version
+++ b/bin/sqoop-version
@@ -19,7 +19,81 @@
 # specific language governing permissions and limitations
 # under the License.

-prgm=`readlink -f $0`
+follow_one() {
+  # Resolve symlinks and relative path components along a path.  This requires
+  # its argument to be an absolute path.  This does not recursively re-resolve
+  # symlinks; if that is required, use the 'follow' method.
+
+  target=$1
+  OIFS=$IFS
+  IFS='/'
+
+  # Taking each dir component along the way, build up a new target directory,
+  # resolving '.', '..', and symlinks.
+  newtarget=''
+  for part in ${target}; do
+    if [ -z "${part}" ]; then
+      continue # Empty dir part. 'foo//bar'
+    elif [ "." == "${part}" ]; then
+      continue # Nothing special to do for '.'
+    elif  [ ".." == "${part}" ]; then
+      IFS=$OIFS
+      newtarget=`dirname ${newtarget}` # pop a component.
+    elif [ -h "${newtarget}/${part}" ]; then
+      IFS=$OIFS
+      link=`readlink ${newtarget}/${part}`
+      # links can be relative or absolute. Relative ones get appended to
+      # newtarget; absolute ones replace it.
+      if [ "${link:0:1}" != "/"  ]; then
+        newtarget="${newtarget}/${link}" # relative
+      else
+        newtarget="${link}" # absolute
+      fi
+    else # Regular file component.
+      newtarget="${newtarget}/${part}"
+    fi
+    IFS='/'
+  done
+
+  IFS=$OIFS
+  echo $newtarget
+}
+
+follow() {
+  # Portable 'readlink -f' function to follow a file's links to the final
+  # target.  Calls follow_one recursively til we're finished tracing symlinks.
+
+  target=$1
+  depth=$2
+
+  if [ -z "$depth" ]; then
+    depth=0
+  elif [ "$depth" == "1000" ]; then
+    # Don't recurse indefinitely; we've probably hit a symlink cycle.
+    # Just bail out here.
+    echo $target
+    return 1
+  fi
+
+  # Canonicalize the target to be an absolute path.
+  targetdir=`dirname ${target}`
+  targetdir=`cd ${targetdir} && pwd`
+  target=${targetdir}/`basename ${target}`
+
+  # Use follow_one to resolve links. Test that we get the same result twice,
+  # to terminate iteration.
+  first=`follow_one ${target}`
+  second=`follow_one ${first}`
+  if [ "${first}" == "${second}" ]; then
+    # We're done.
+    echo "${second}"
+  else
+    # Need to continue resolving links.
+    echo `follow ${second} $(( $depth + 1 ))`
+  fi
+}
+
+prgm=`follow $0`
 bin=`dirname ${prgm}`
 bin=`cd ${bin} && pwd`
