1.Storm 安装手册和提交Topology

目录

（一）搭建单机storm集群

一、下载所需要的资源

二、资源解压

三、安装JDK

四、安装依赖的库文件

五、安装ZMQ

六、安装jzmq

七、启动zookeeper

八、启动storm

九、在UI端访问

十、编译storm-start jar包

十一、storm-starter源码导出

十二、提交Topology

（二）搭建多机storm集群

一、基本设置

二、修改配置文件

三、启动集群

四、在UI端口访问

五、提交Topology

附一

Storm 安装手册

（一）搭建单机storm集群

一、下载所需要的资源

Storm:

http://storm-project.net/downloads.html

（0.9.3）apache-storm-0.9.3.tar.gz

Zookeeper:

http://www.apache.org/dyn/closer.cgi/zookeeper/

（3.4.6）zookeeper-3.4.6.tar.gz

ZMQ:

http://download.zeromq.org/

（2.1.7）zeromq-2.1.7.tar.gz

jzmq:

http://github.com/nathanmarz/jzmq/archive/master.zip

jzmq-master.zip

二、资源解压

下载完成后将资源放在自己指定的目录下

解压

tar -xvf zookeeper-3.4.6.tar.gz

tar -xvf apache-storm-0.9.3.tar.gz

tar -xvf zeromq-2.1.7.tar.gz

unzip jzmq-master.zip

三、安装JDK

安装openjdk

安装命令：

sudo apt-get install openjdk-7-jdk

安装完成后修改环境变量，修改文件etc/profile

vim /etc/profile

修改以下内容：

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-i386

export CLASSPATH=$JAVA_HOME/lib

export PATH=$JAVA_HOME/bin:$PATH

修改完成后，使配置文件生效

source /etc/profile

四、安装依赖的库文件

运行以下命令对所需要的库文件进行安装，也可使用yum进行安装

sudo apt-get install libtool

sudo apt-get install autoconf

sudo apt-get install automake

sudo apt-get install g++

sudo apt-get install uuid-dev

sudo apt-get install uuid

sudo apt-get install e2fsprogs

sudo apt-get install python

五、安装ZMQ

进入zero相应目录下，运行以下命令进行安装

cd zeromq-2.1.7

./configure

若出现如下错误

configure: error: cannot link with -luuid, install uuid-dev.

解决方案如下：

yum install uuid-dev 提示找不到该依赖包  (需从网上下载安装yum)

yum install uuid*     直接用* ok

./configure  再次运行configure还是报错

configure: error: cannot link with -luuid, install uuid-dev.

上网搜索可能是还缺另外一个包

yum install e2fsprogs* ok

make

sudo make install

sudo ldconfig

六、安装jzmq

进入jzmq相应目录下，运行以下命令进行安装

cd jzmq-master

./autogen.sh

./configure

make

sudo make install

若make过程出现如下错误

***No rule to make target ‘classdist_noinst.stamp’,needed by ‘org、zeromq/ZMQ.class’. Stop

解决方法，运行如下命令解决

touch src/classdist_noinst.stamp

cd src/org/zeromq

javac *.java

cd –

make

sudo make install

七、启动zookeeper

进入zookeeper相应目录

cd zookeeper-3.4.6/

重命名./conf/zoo_sample.cfg为./conf/zoo.cfg

mv ./conf/zoo_sample.cfg ./conf/zoo.cfg

运行命令启动zookeeper

bin/zkServer.sh start

检查zookeeper是否启动成功zkServer.sh status

bin/zkCli.sh –server 127.0.0.1:2181

在出现的交互式窗口中运行

ls /

八、启动storm

进入storm相应目录，启动storm相应服务

cd apache-storm-0.9.3/bin

./storm nimbus&

./storm supervisor&

./storm ui&

九、在UI端访问

在桌面打开连接http://localhost:8080，此时能够看见Storm UI界面

十、编译storm-start jar包

在运行起来的集群上提交一个Topology，使用storm-starter做示范

安装git工具

sudo apt-get install git

安装leiningen工具（2.0.0以上版本），按照https://github.com/technomancy/leiningen的步骤安装

确保java版本在6以上

下载lein脚本（我下载的lein脚本附在最后，附一），命名为lein：

cd ~/wfm-storm/apache-storm-0.9.3/bin

vim lein

将附一的脚本粘贴到lein文件中并保存

chmod 755 ~/bin/lein

运行lein

./lein

运行lein报如下错误

“Failed to download

https://github.com/technomancy/leiningen/releases/download/2.5.0/leiningen-2.5.0-standalone.jar  (exit code 7) It's possible your HTTP client's certificate store does not have the correct certificate authority needed. This is often caused by an out-of-date version of libssl. It's also possible that you're behind a firewall and haven't set HTTP_PROXY and HTTPS_PROXY.“

解决方法：

export HTTP_CLIENT="wget --no-check-certificate -O"

./lein

export PATH=" ~/wfm-storm/apache-storm-0.9.3/bin/:$PATH"（在配置文件中加入这句）

下载storm-start源码保存在~/wfm-storm/storm-starter中

cd ~/wfm-storm/

git clone git://github.com/nathanmarz/storm-starter.git

依次执行以下命令创建项目jar包

cd storm-starter/

lein deps //下载相应的依赖包

lein compile //编译

lein install //安装打包

报backtype.storm.LocalCluster和backtype.storm.LocalDRPC类找不到：

Compiling backtype.storm.testing4j

Exception in thread "main" java.lang.ClassNotFoundException: backtype.storm.LocalCluster, compiling:(testing4j.clj:1)

        at clojure.lang.Compiler$InvokeExpr.eval(Compiler.java:3387)

        at clojure.lang.Compiler.compile1(Compiler.java:7035)

        at clojure.lang.Compiler.compile1(Compiler.java:7025)

        at clojure.lang.Compiler.compile(Compiler.java:7097)

        at clojure.lang.RT.compile(RT.java:387)

        at clojure.lang.RT.load(RT.java:427)

        at clojure.lang.RT.load(RT.java:400)

        at clojure.core$load$fn__4890.invoke(core.clj:5415)

        at clojure.core$load.doInvoke(core.clj:5414)

解决方法：

修改storm-core/src/clj/backtype/storm/testing4j.clj

和storm-core/src/clj/storm/trident/testing.clj，分别引用这两个类：

testing4j.clj：

  1 (ns backtype.storm.testing4j

  2   (:import [java.util Map List Collection ArrayList])

  3   (:require [backtype.storm.LocalCluster :as LocalCluster])

testing.clj：

  1  (ns storm.trident.testing)

  2   (:require [backtype.storm.LocalDRPC :as LocalDRPC])

安装时出现jdk版本问题

sudo apt-get install openjdk-7-jdk

执行之后会将JDK安装到/usr/lib/jvm/java-7-openjdk-i386/

通过update-alternatives选择系统中使用的java

sudo update-alternatives --config java

有 3 个候选项可用于替换 java (提供 /usr/bin/java)。

选择  路径                         优先级  状态

------------------------------------------------------------

* 0   /usr/lib/jvm/java-6-openjdk-i386/jre/bin/java   1061      自动模式

1    /usr/lib/jvm/java-6-openjdk-i386/jre/bin/java   1061      手动模式

2    /usr/lib/jvm/java-6-sun/jre/bin/java            63        手动模式

3    /usr/lib/jvm/java-7-openjdk-i386/jre/bin/java   1051      手动模式

要维持当前值[*]请按回车键，或者键入选择的编号：3      

update-alternatives: 使用 /usr/lib/jvm/java-7-openjdk-i386/jre/bin/java 来提供 /usr/bin/java (java)，于 手动模式 中。

实际是将/usr/bin/java链接到JDK7上，保证执行java命令后，实际运行的是我们的目标版本

java -version

除了java外，还有javac、jar、javah、javap、jps、jconsole等

sudo update-alternatives --config javac

sudo update-alternatives --config jar

sudo update-alternatives --config javah

sudo update-alternatives --config javap

sudo update-alternatives --config jps

sudo update-alternatives --config jconsole

补充：jps -lv  用于查看java程序的启动参数，如java版本

修改各个环境变量

sudo vim /etc/profile

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64/

export CLASSPATH=$JAVA_HOME/lib

export PATH=$JAVA_HOME/bin:$PATH

source  /etc/profile

sudo vim /etc/environment

CLASSPATH=.:/usr/lib/jvm/java-7-openjdk-amd64/lib#

JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64/source /etc/environment

sudo vim ~/.bashrc

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64/

export CLASSPATH=$JAVA_HOME/lib

export PATH=$JAVA_HOME/bin:$PATH

source ~/.bashrc

创建好的jar包storm-starter-0.0.1-SNAPSHOT.jar位于target目录下

十一、storm-starter源码导出

获取storm-starter源码

cd ~/wfm-storm

git clone git://github.com/apache/storm.git

cd storm/examples/storm-starter

storm-starter简介

storm-starter包含很多使用storm的例子。如果是第一次使用storm，建议从以下三个例子（topologies）入手：

- ExclamationTopology: 基础的topology，全部都是使用java写的

- WordCountTopology: 基础的topology ，利用multilang使用Python实现的

- ReachTopology: storm之上的复杂的DRPC例子

熟悉这几个例子之后，可看看其他的一些topologies（src/jvm/storm/starter/），其中有更多advanced的实现例子

在maven上使用storm-starter，安装maven（3.x）

下载相应maven版本（http://maven.apache.org/download.cgi），例如apache-maven-3.2.5-bin.tar.gz

解压下载的包

tar -zxf apache-maven-3.2.5-bin.tar.gz

修改环境变量M2_HOME

sudo vim /etc/profile

添加如下代码：

export M2_HOME=/home/wamdm/wfm-storm/apache-maven-3.2.5

export M2=$M2_HOME/bin

export MAVEN_OPTS="-Xms256m -Xmx512m"

export PATH=$M2:$PATH

source /etc/profile

运行mvn –version查看安装是否成功.

在maven上运行topologies

storm-starter topologies可以使用maven-exec-plugin执行

例如：在本地模式下编译并且运行 WordCountTopology

$ mvn compile exec:java -Dstorm.topology=storm.starter.WordCountTopology

也可以使用Maven运行clojure topologies

$ mvn compile exec:java -Dstorm.topology=storm.starter.clj.word_count

打包strom-starter用于storm集群

mvn package

运行例子：

# Example 1: Run the RollingTopWords in local mode (LocalCluster)

$ storm jar storm-starter-*-jar-with-dependencies.jar storm.starter.RollingTopWords

# Example 2: Run the RollingTopWords in remote/cluster mode,

# under the name "production-topology"

$ storm jar storm-starter-*-jar-with-dependencies.jar storm.starter.RollingTopWords production-topology remote

十二、提交Topology

进入storm文件夹的bin目录中，运行以下命令提交Topology

./storm jar ~/project/storm-starter/target/storm-starter-0.0.1-SNAPSHOT.jar storm.starter.WordCount Topology wordcount

等待提交结束，刷新ui页面，可以看到提交的“Wordcount”Topology，点击Wordcount可以看到其详细的运行情况

停止storm Topology

storm kill ：{toponame}

（二）搭建多机storm集群

一、基本设置

首先在每台机器上都搭建单机集群

wamdm1作为Nimbus（192.168.0.11）

wamdm2作为Zookeeper（192.168.0.12）

wamdm3作为Supervisor（192.168.0.13）

wamdm4作为Supervisor（192.168.0.14）

二、修改配置文件

修改wamdm1、wamdm3、wamdm4上的storm.yaml

（~/wfm-storm/apache-storm-0.9.3/conf）

进入conf目录

cd ~/wfm-storm/apache-storm-0.9.3/conf

修改配置文件

vim storm.yaml

将文件中添加如下代码

storm.zookeeper.servers:

- "192.168.0.12"

# - "192.168.0.13"

nimbus.host: "192.168.0.11"

#ui.port: 83

supervisor.slots.ports:

- 6700

- 6701

- 6702

- 6703

可用参数解释：

java.library.path：该配置项配置启动storm所需lib包的路径（默认可不用配置）

storm.zookeeper.servers：该配置项配置了当前集群中所有ZooKeeper机器的IP地址（这里我们只使用wamdm1作为Zookeeper服务器）

nimbus.host：该配置项指明了Nimbus机器的IP地址

ui.port：该配置项配置了Storm UI使用的端口。（默认使用8080端口）

supervisor.slots.ports：该配置项指明了一台Supervisor机器上所有可以使用的slot信息，也就是端口号。表明该机器上最多可以启动4个worker

Storm还提供了很多其他的配置项，需要时可查相应的document

三、启动集群

在wamdm2上启动zookeeper

bin/zkServer.sh start

检查zookeeper是否启动成功zkServer.sh status

bin/zkCli.sh –server 127.0.0.1:2181

在出现的交互式窗口中运行

ls /

在wamdm1上启动nimbus和ui

cd apache-storm-0.9.3/bin

./storm nimbus

./storm ui

在wamdm3上启动supervisor

cd apache-storm-0.9.3/bin

./storm supervisor

在wamdm4上启动supervisor

cd apache-storm-0.9.3/bin

./storm supervisor

四、在UI端口访问

在桌面打开连接http://192.168.0.11:8080，此时能够看见Storm集群

五、提交Topology

在wamdm1（Nimbus所在机器）上提交WordCountTopology到集群中，刷新ui页面，就能够看到提交的Topology了。

附一

lein

#!/usr/bin/env bash

# Ensure this file is executable via `chmod a+x lein`, then place it

# somewhere on your $PATH, like ~/bin. The rest of Leiningen will be

# installed upon first run into the ~/.lein/self-installs directory.

export LEIN_VERSION="2.5.0"

case $LEIN_VERSION in

    *SNAPSHOT) SNAPSHOT="YES" ;;

    *) SNAPSHOT="NO" ;;

esac

if [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "msys" ]]; then

    delimiter=";"

else

    delimiter=":"

fi

if [[ "$OSTYPE" == "cygwin" ]]; then

  cygwin=true

else

  cygwin=false

fi

function make_native_path {

    # ensure we have native paths

    if $cygwin && [[ "$1"  == /* ]]; then

    echo -n "$(cygpath -wp "$1")"

    elif [[ "$OSTYPE" == "msys" && "$1"  == /?/* ]]; then

    echo -n "$(sh -c "(cd $1 2</dev/null && pwd -W) || echo $1 | sed 's/^\\/\([a-z]\)/\\1:/g'")"

    else

    echo -n "$1"

    fi

}

#  usage : add_path PATH_VAR [PATH]...

function add_path {

    local path_var="$1"

    shift

    while [ -n "$1" ];do

        # http://bashify.com/?Useful_Techniques:Indirect_Variables:Indirect_Assignment

        if [[ -z ${!path_var} ]]; then

          export ${path_var}="$(make_native_path "$1")"

        else

          export ${path_var}="${!path_var}${delimiter}$(make_native_path "$1")"

        fi

    shift

    done

}

function download_failed_message {

    echo "Failed to download $1 (exit code $2)"

    echo "It's possible your HTTP client's certificate store does not have the"

    echo "correct certificate authority needed. This is often caused by an"

    echo "out-of-date version of libssl. It's also possible that you're behind a"

    echo "firewall and haven't set HTTP_PROXY and HTTPS_PROXY."

}

function self_install {

  if [ -r "$LEIN_JAR" ]; then

    echo "The self-install jar already exists at $LEIN_JAR."

    echo "If you wish to re-download, delete it and rerun \"$0 self-install\"."

    exit 1

  fi

  echo "Downloading Leiningen to $LEIN_JAR now..."

  mkdir -p "$(dirname "$LEIN_JAR")"

  LEIN_URL="https://github.com/technomancy/leiningen/releases/download/$LEIN_VERSION/leiningen-$LEIN_VERSION-standalone.jar"

  $HTTP_CLIENT "$LEIN_JAR.pending" "$LEIN_URL"

  local exit_code=$?

  if [ $exit_code == 0 ]; then

      # TODO: checksum

      mv -f "$LEIN_JAR.pending" "$LEIN_JAR"

  else

      rm "$LEIN_JAR.pending" 2> /dev/null

      download_failed_message "$LEIN_URL" "$exit_code"

      exit 1

  fi

}

if [ `id -u` -eq 0 ] && [ "$LEIN_ROOT" = "" ]; then

    echo "WARNING: You're currently running as root; probably by accident."

    echo "Press control-C to abort or Enter to continue as root."

    echo "Set LEIN_ROOT to disable this warning."

    read _

fi

NOT_FOUND=1

ORIGINAL_PWD="$PWD"

while [ ! -r "$PWD/project.clj" ] && [ "$PWD" != "/" ] && [ $NOT_FOUND -ne 0 ]

do

    cd ..

    if [ "$(dirname "$PWD")" = "/" ]; then

        NOT_FOUND=0

        cd "$ORIGINAL_PWD"

    fi

done

export LEIN_HOME="${LEIN_HOME:-"$HOME/.lein"}"

for f in "$LEIN_HOME/leinrc" ".leinrc"; do

  if [ -e "$f" ]; then

    source "$f"

  fi

done

if $cygwin; then

    export LEIN_HOME=`cygpath -w "$LEIN_HOME"`

fi

LEIN_JAR="$LEIN_HOME/self-installs/leiningen-$LEIN_VERSION-standalone.jar"

# normalize $0 on certain BSDs

if [ "$(dirname "$0")" = "." ]; then

    SCRIPT="$(which $(basename "$0"))"

else

    SCRIPT="$0"

fi

# resolve symlinks to the script itself portably

while [ -h "$SCRIPT" ] ; do

    ls=`ls -ld "$SCRIPT"`

    link=`expr "$ls" : '.*-> \(.*\)$'`

    if expr "$link" : '/.*' > /dev/null; then

        SCRIPT="$link"

    else

        SCRIPT="$(dirname "$SCRIPT"$)/$link"

    fi

done

BIN_DIR="$(dirname "$SCRIPT")"

export LEIN_JVM_OPTS="${LEIN_JVM_OPTS-"-XX:+TieredCompilation -XX:TieredStopAtLevel=1"}"

# This needs to be defined before we call HTTP_CLIENT below

if [ "$HTTP_CLIENT" = "" ]; then

    if type -p curl >/dev/null 2>&1; then

        if [ "$https_proxy" != "" ]; then

            CURL_PROXY="-x $https_proxy"

        fi

        HTTP_CLIENT="curl $CURL_PROXY -f -L -o"

    else

        HTTP_CLIENT="wget -O"

    fi

fi

# When :eval-in :classloader we need more memory

grep -E -q '^\s*:eval-in\s+:classloader\s*$' project.clj 2> /dev/null && \

    export LEIN_JVM_OPTS="$LEIN_JVM_OPTS -Xms64m -Xmx512m"

if [ -r "$BIN_DIR/../src/leiningen/version.clj" ]; then

    # Running from source checkout

    LEIN_DIR="$(dirname "$BIN_DIR")"

    # Need to use lein release to bootstrap the leiningen-core library (for aether)

    if [ ! -r "$LEIN_DIR/leiningen-core/.lein-bootstrap" ]; then

        echo "Leiningen is missing its dependencies."

        echo "Please run \"lein bootstrap\" in the leiningen-core/ directory"

        echo "with a stable release of Leiningen. See CONTRIBUTING.md for details."

        exit 1

    fi

    # If project.clj for lein or leiningen-core changes, we must recalculate

    LAST_PROJECT_CHECKSUM=$(cat "$LEIN_DIR/.lein-project-checksum" 2> /dev/null)

    PROJECT_CHECKSUM=$(sum "$LEIN_DIR/project.clj" "$LEIN_DIR/leiningen-core/project.clj")

    if [ "$PROJECT_CHECKSUM" != "$LAST_PROJECT_CHECKSUM" ]; then

        if [ -r "$LEIN_DIR/.lein-classpath" ]; then

            rm "$LEIN_DIR/.lein-classpath"

        fi

    fi

    # Use bin/lein to calculate its own classpath.

    if [ ! -r "$LEIN_DIR/.lein-classpath" ] && [ "$1" != "classpath" ]; then

        echo "Recalculating Leiningen's classpath."

        ORIG_PWD="$PWD"

        cd "$LEIN_DIR"

        LEIN_NO_USER_PROFILES=1 $0 classpath .lein-classpath

        sum "$LEIN_DIR/project.clj" "$LEIN_DIR/leiningen-core/project.clj" > \

            .lein-project-checksum

        cd "$ORIG_PWD"

    fi

    mkdir -p "$LEIN_DIR/target/classes"

    export LEIN_JVM_OPTS="$LEIN_JVM_OPTS -Dclojure.compile.path=$LEIN_DIR/target/classes"

    add_path CLASSPATH "$LEIN_DIR/leiningen-core/src/" "$LEIN_DIR/leiningen-core/resources/" \

        "$LEIN_DIR/test:$LEIN_DIR/target/classes" "$LEIN_DIR/src" ":$LEIN_DIR/resources"

    if [ -r "$LEIN_DIR/.lein-classpath" ]; then

        add_path CLASSPATH "$(cat "$LEIN_DIR/.lein-classpath" 2> /dev/null)"

    else

        add_path CLASSPATH "$(cat "$LEIN_DIR/leiningen-core/.lein-bootstrap" 2> /dev/null)"

    fi

else # Not running from a checkout

    add_path CLASSPATH "$LEIN_JAR"

    BOOTCLASSPATH="-Xbootclasspath/a:$LEIN_JAR"

    if [ ! -r "$LEIN_JAR" -a "$1" != "self-install" ]; then

        self_install

    fi

fi

# TODO: explain what to do when Java is missing

export JAVA_CMD="${JAVA_CMD:-"java"}"

export LEIN_JAVA_CMD="${LEIN_JAVA_CMD:-$JAVA_CMD}"

if [[ -z "${DRIP_INIT+x}" && "$(basename "$LEIN_JAVA_CMD")" == *drip* ]]; then

    export DRIP_INIT="$(printf -- '-e\n(require (quote leiningen.repl))')"

    export DRIP_INIT_CLASS="clojure.main"

fi

# Support $JAVA_OPTS for backwards-compatibility.

export JVM_OPTS="${JVM_OPTS:-"$JAVA_OPTS"}"

# Handle jline issue with cygwin not propagating OSTYPE through java subprocesses: https://github.com/jline/jline2/issues/62

cygterm=false

if $cygwin; then

  case "$TERM" in

    rxvt* | xterm* | vt*) cygterm=true ;;

  esac

fi

if $cygterm; then

  LEIN_JVM_OPTS="$LEIN_JVM_OPTS -Djline.terminal=jline.UnixTerminal"

  stty -icanon min 1 -echo > /dev/null 2>&1

fi

# TODO: investigate http://skife.org/java/unix/2011/06/20/really_executable_jars.html

# If you're packaging this for a package manager (.deb, homebrew, etc)

# you need to remove the self-install and upgrade functionality or see lein-pkg.

if [ "$1" = "self-install" ]; then

    if [ -r "$BIN_DIR/../src/leiningen/version.clj" ]; then

        echo "Running self-install from a checkout is not supported."

        echo "See CONTRIBUTING.md for SNAPSHOT-specific build instructions."

        exit 1

    fi

    echo "Manual self-install is deprecated; it will run automatically when necessary."

    self_install

elif [ "$1" = "upgrade" ] || [ "$1" = "downgrade" ]; then

    if [ "$LEIN_DIR" != "" ]; then

        echo "The upgrade task is not meant to be run from a checkout."

        exit 1

    fi

    if [ $SNAPSHOT = "YES" ]; then

        echo "The upgrade task is only meant for stable releases."

        echo "See the \"Hacking\" section of the README."

        exit 1

    fi

    if [ ! -w "$SCRIPT" ]; then

        echo "You do not have permission to upgrade the installation in $SCRIPT"

        exit 1

    else

        TARGET_VERSION="${2:-stable}"

        echo "The script at $SCRIPT will be upgraded to the latest $TARGET_VERSION version."

        echo -n "Do you want to continue [Y/n]? "

        read RESP

        case "$RESP" in

            y|Y|"")

                echo

                echo "Upgrading..."

                TARGET="/tmp/lein-$$-upgrade"

                if $cygwin; then

                    TARGET=`cygpath -w $TARGET`

                fi

                LEIN_SCRIPT_URL="https://github.com/technomancy/leiningen/raw/$TARGET_VERSION/bin/lein"

                $HTTP_CLIENT "$TARGET" "$LEIN_SCRIPT_URL"

                if [ $? == 0 ]; then

                    cmp -s "$TARGET" "$SCRIPT"

                    if [ $? == 0 ]; then

                        echo "Leiningen is already up-to-date."

                    fi

                    mv "$TARGET" "$SCRIPT" && chmod +x "$SCRIPT"

                    exec "$SCRIPT" version

                else

                    download_failed_message "$LEIN_SCRIPT_URL"

                fi;;

            *)

                echo "Aborted."

                exit 1;;

        esac

    fi

else

    if $cygwin; then

        # When running on Cygwin, use Windows-style paths for java

        ORIGINAL_PWD=`cygpath -w "$ORIGINAL_PWD"`

    fi

    # apply context specific CLASSPATH entries

    if [ -f .lein-classpath ]; then

        add_path CLASSPATH "$(cat .lein-classpath)"

    fi

    if [ $DEBUG ]; then

        echo "Leiningen's classpath: $CLASSPATH"

    fi

    if [ -r .lein-fast-trampoline ]; then

        export LEIN_FAST_TRAMPOLINE='y'

    fi

    if [ "$LEIN_FAST_TRAMPOLINE" != "" ] && [ -r project.clj ]; then

        INPUTS="$@ $(cat project.clj) $LEIN_VERSION $(test -f "$LEIN_HOME/profiles.clj" && cat "$LEIN_HOME/profiles.clj")"

        export INPUT_CHECKSUM=$(echo $INPUTS | shasum - | cut -f 1 -d " ")

        # Just don't change :target-path in project.clj, mkay?

        TRAMPOLINE_FILE="target/trampolines/$INPUT_CHECKSUM"

    else

        if hash mktemp 2>/dev/null; then

            # Check if mktemp is available before using it

            TRAMPOLINE_FILE="$(mktemp /tmp/lein-trampoline-XXXXXXXXXXXXX)"

        else

            TRAMPOLINE_FILE="/tmp/lein-trampoline-$$"

        fi

        trap "rm -f $TRAMPOLINE_FILE" EXIT

    fi

    if $cygwin; then

        TRAMPOLINE_FILE=`cygpath -w $TRAMPOLINE_FILE`

    fi

    if [ "$INPUT_CHECKSUM" != "" ] && [ -r "$TRAMPOLINE_FILE" ]; then

        if [ $DEBUG ]; then

            echo "Fast trampoline with $TRAMPOLINE_FILE."

        fi

        exec sh -c "exec $(cat $TRAMPOLINE_FILE)"

    else

        export TRAMPOLINE_FILE

        "$LEIN_JAVA_CMD" \

            "${BOOTCLASSPATH[@]}" \

            -Dfile.encoding=UTF-8 \

            -Dmaven.wagon.http.ssl.easy=false \

            -Dmaven.wagon.rto=10000 \

            $LEIN_JVM_OPTS \

            -Dleiningen.original.pwd="$ORIGINAL_PWD" \

            -Dleiningen.script="$SCRIPT" \

            -classpath "$CLASSPATH" \

            clojure.main -m leiningen.core.main "$@"

        EXIT_CODE=$?

        if $cygterm ; then

          stty icanon echo > /dev/null 2>&1

        fi

        ## TODO: [ -r "$TRAMPOLINE_FILE" ] may be redundant? A trampoline file

        ## is always generated these days.

        if [ -r "$TRAMPOLINE_FILE" ] && [ "$LEIN_TRAMPOLINE_WARMUP" = "" ]; then

            TRAMPOLINE="$(cat $TRAMPOLINE_FILE)"

            if [ "$INPUT_CHECKSUM" = "" ]; then

                rm $TRAMPOLINE_FILE

            fi

            if [ "$TRAMPOLINE" = "" ]; then

                exit $EXIT_CODE

            else

                exec sh -c "exec $TRAMPOLINE"

            fi

        else

            exit $EXIT_CODE

        fi

    fi

fi