web-dev-qa-db-ja.com

Ubuntu 10.04でのTomcatの起動とシャットダウンに関するいくつかの問題に直面

Tomcatの起動とシャットダウンに関する問題に直面しています。

私は使っている

  1. Tomcat v.6.0.32(Ubuntu 10.04によって配布されたものではなく、Apache Webサイトからダウンロードされたバンドルを使用して抽出)
  2. Ubuntu v.10.04

コマンドを使用してTomcatを起動します:

$./catalina.sh jpda start

次に、コマンドを使用して停止しようとします:

$./catalina.sh stop

そして、次のメッセージを取得します。

SEVERE: Catalina.stop: 
Java.net.ConnectException: Connection refused
    at Java.net.PlainSocketImpl.socketConnect(Native Method)
    at Java.net.PlainSocketImpl.doConnect(PlainSocketImpl.Java:351)
    at Java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.Java:213)
    at Java.net.PlainSocketImpl.connect(PlainSocketImpl.Java:200)
    at Java.net.SocksSocketImpl.connect(SocksSocketImpl.Java:366)
    at Java.net.Socket.connect(Socket.Java:529)
    at Java.net.Socket.connect(Socket.Java:478)
    at Java.net.Socket.<init>(Socket.Java:375)
    at Java.net.Socket.<init>(Socket.Java:189)
    at org.Apache.catalina.startup.Catalina.stopServer(Catalina.Java:422)
    at Sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at Sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.Java:39)
    at Sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.Java:25)
    at Java.lang.reflect.Method.invoke(Method.Java:597)
    at org.Apache.catalina.startup.Bootstrap.stopServer(Bootstrap.Java:338)
    at org.Apache.catalina.startup.Bootstrap.main(Bootstrap.Java:416)

また、コマンドを使用して停止しようとしました:

$./catalina.sh stop -force

しかし、私はメッセージを受け取りました:

Kill failed: $CATALINA_PID not set

次に、コマンドを使用してTomcatを起動しようとしました:

$./catalina.sh jpda start

/ logsフォルダーでは、catalina.outのみが生成され、次のエラーメッセージが表示されます。

ERROR: transport error 202: bind failed: Address already in use
ERROR: JDWP Transport dt_socket failed to initialize, TRANSPORT_INIT(510)
JDWP exit error AGENT_ERROR_TRANSPORT_INIT(197): No transports initialized [../../../src/share/back/debugInit.c:690]
FATAL ERROR in native method: JDWP No transports initialized, jvmtiError=AGENT_ERROR_TRANSPORT_INIT(197)

「アドレスはすでに使用されています」というエラーに示されているように、ポート8080で実行するように他のアプリケーションが構成されていないことを確認しました。これには、Tomcatサーバーを停止する必要があるときに、「KILL」コマンドを使用して手動でプロセスを強制終了する必要があります。 上記と同じ環境が設定されている他のマシンでも、この同じ動作が発生しています。

誰がこれを引き起こしているのか、これを解決する方法を教えてください。

おかげで、
Jignesh

24
Jignesh Gohel

Tomcatのシャットダウンの問題を修正しました。参照用にここにソリューションを投稿します。

以下を実行して、マシン上で修正します。

1) Replace $CATALINA_HOME/bin/catalina.sh with catalina.sh shown below.
2) Open /etc/bash.bashrc for edit
3) Add following into it, (AFTER export CATALINA_HOME)
          export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt",

          where $CATALINA_HOME is the Tomcat home path

 4) Execute following :
      $ source /etc/bash.bashrc

 5) Start Tomcat: $CATALINA_HOME/bin/catalina.sh start (or catalina.sh jpda start)

 6) Shutdown Tomcat using following command only for proper shutdown:
        $CATALINA_HOME/bin/catalina.sh stop -force

catalina.sh-インラインコメントが含まれています

        #!/bin/sh

        # Licensed to the Apache Software Foundation (ASF) under one or more
        # contributor license agreements.  See the NOTICE file distributed with
        # this work for additional information regarding copyright ownership.
        # The ASF licenses this file to You under the Apache License, Version 2.0
        # (the "License"); you may not use this file except in compliance with
        # the License.  You may obtain a copy of the License at
        #
        #     http://www.Apache.org/licenses/LICENSE-2.0
        #
        # Unless required by applicable law or agreed to in writing, software
        # distributed under the License is distributed on an "AS IS" BASIS,
        # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        # See the License for the specific language governing permissions and
        # limitations under the License.

        # -----------------------------------------------------------------------------
        # Start/Stop Script for the CATALINA Server
        #
        # Environment Variable Prerequisites
        #
        #   CATALINA_HOME   May point at your Catalina "build" directory.
        #
        #   CATALINA_BASE   (Optional) Base directory for resolving dynamic portions
        #                   of a Catalina installation.  If not present, resolves to
        #                   the same directory that CATALINA_HOME points to.
        #
        #   CATALINA_OUT    (Optional) Full path to a file where stdout and stderr
        #                   will be redirected.
        #                   Default is $CATALINA_BASE/logs/catalina.out
        #
        #   CATALINA_OPTS   (Optional) Java runtime options used when the "start",
        #                   or "run" command is executed.
        #
        #   CATALINA_TMPDIR (Optional) Directory path location of temporary directory
        #                   the JVM should use (Java.io.tmpdir).  Defaults to
        #                   $CATALINA_BASE/temp.
        #
        #   Java_HOME       Must point at your Java Development Kit installation.
        #                   Required to run the with the "debug" argument.
        #
        #   JRE_HOME        Must point at your Java Development Kit installation.
        #                   Defaults to Java_HOME if empty.
        #
        #   Java_OPTS       (Optional) Java runtime options used when the "start",
        #                   "stop", or "run" command is executed.
        #
        #   Java_ENDORSED_DIRS (Optional) Lists of of colon separated directories
        #                   containing some jars in order to allow replacement of APIs
        #                   created outside of the JCP (i.e. DOM and SAX from W3C).
        #                   It can also be used to update the XML parser implementation.
        #                   Defaults to $CATALINA_HOME/endorsed.
        #
        #   JPDA_TRANSPORT  (Optional) JPDA transport used when the "jpda start"
        #                   command is executed. The default is "dt_socket".
        #
        #   JPDA_ADDRESS    (Optional) Java runtime options used when the "jpda start"
        #                   command is executed. The default is 8000.
        #
        #   JPDA_SUSPEND    (Optional) Java runtime options used when the "jpda start"
        #                   command is executed. Specifies whether JVM should suspend
        #                   execution immediately after startup. Default is "n".
        #
        #   JPDA_OPTS       (Optional) Java runtime options used when the "jpda start"
        #                   command is executed. If used, JPDA_TRANSPORT, JPDA_ADDRESS,
        #                   and JPDA_SUSPEND are ignored. Thus, all required jpda
        #                   options MUST be specified. The default is:
        #
        #                   -agentlib:jdwp=transport=$JPDA_TRANSPORT,
        #                       address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND
        #
        #   CATALINA_PID    (Optional) Path of the file which should contains the pid
        #                   of catalina startup Java process, when start (fork) is used
        #
        #   LOGGING_CONFIG  (Optional) Override Tomcat's logging config file
        #                   Example (all one line)
        #                   LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"
        #
        #   LOGGING_MANAGER (Optional) Override Tomcat's logging manager
        #                   Example (all one line)
        #                   LOGGING_MANAGER="-Djava.util.logging.manager=org.Apache.juli.ClassLoaderLogManager"
        #
        # $Id: catalina.sh 1040547 2010-11-30 14:47:49Z markt $
        # -----------------------------------------------------------------------------

        # OS specific support.  $var _must_ be set to either true or false.
        cygwin=false
        os400=false
        darwin=false
        case "`uname`" in
        CYGWIN*) cygwin=true;;
        OS400*) os400=true;;
        Darwin*) darwin=true;;
        esac

        # resolve links - $0 may be a softlink
        PRG="$0"

        while [ -h "$PRG" ]; do
            ls=`ls -ld "$PRG"`
            link=`expr "$ls" : '.*-> \(.*\)$'`
            if expr "$link" : '/.*' > /dev/null; then
                PRG="$link"
            else
                PRG=`dirname "$PRG"`/"$link"
            fi
        done

        # Get standard environment variables
        PRGDIR=`dirname "$PRG"`

        # Only set CATALINA_HOME if not already set
        [ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`

        # Ensure that any user defined CLASSPATH variables are not used on startup,
        # but allow them to be specified in setenv.sh, in rare case when it is needed.
        CLASSPATH=

        if [ -r "$CATALINA_BASE"/bin/setenv.sh ]; then
            . "$CATALINA_BASE"/bin/setenv.sh
        Elif [ -r "$CATALINA_HOME"/bin/setenv.sh ]; then
            . "$CATALINA_HOME"/bin/setenv.sh
        fi

        # For Cygwin, ensure paths are in UNIX format before anything is touched
        if $cygwin; then
            [ -n "$Java_HOME" ] && Java_HOME=`cygpath --unix "$Java_HOME"`
            [ -n "$JRE_HOME" ] && JRE_HOME=`cygpath --unix "$JRE_HOME"`
            [ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"`
            [ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"`
            [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
        fi

        # For OS400
        if $os400; then
            # Set job priority to standard for interactive (interactive - 6) by using
            # the interactive priority - 6, the helper threads that respond to requests
            # will be running at the same priority as interactive jobs.
            COMMAND='chgjob job('$JOBNAME') runpty(6)'
            system $COMMAND

            # Enable multi threading
            export QIBM_MULTI_THREADED=Y
        fi

        # Get standard Java environment variables
        if $os400; then
            # -r will Only work on the os400 if the files are:
            # 1. owned by the user
            # 2. owned by the PRIMARY group of the user
            # this will not work if the user belongs in secondary groups
            BASEDIR="$CATALINA_HOME"
            . "$CATALINA_HOME"/bin/setclasspath.sh
        else
            if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; then
                BASEDIR="$CATALINA_HOME"
                . "$CATALINA_HOME"/bin/setclasspath.sh
            else
                echo "Cannot find $CATALINA_HOME/bin/setclasspath.sh"
                echo "This file is needed to run this program"
                exit 1
            fi
        fi

        if [ -z "$CATALINA_BASE" ] ; then
            CATALINA_BASE="$CATALINA_HOME"
        fi

        # Add Tomcat-juli.jar and bootstrap.jar to classpath
        # Tomcat-juli.jar can be over-ridden per instance
        if [ ! -z "$CLASSPATH" ] ; then
            CLASSPATH="$CLASSPATH":
        fi
        if [ "$CATALINA_BASE" != "$CATALINA_HOME" ] && [ -r "$CATALINA_BASE/bin/Tomcat-juli.jar" ] ; then
            CLASSPATH="$CLASSPATH""$CATALINA_BASE"/bin/Tomcat-juli.jar:"$CATALINA_HOME"/bin/bootstrap.jar
        else
            CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar
        fi

        if [ -z "$CATALINA_OUT" ] ; then
            CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out
        fi

        if [ -z "$CATALINA_TMPDIR" ] ; then
            # Define the Java.io.tmpdir to use for Catalina
            CATALINA_TMPDIR="$CATALINA_BASE"/temp
        fi

        # Bugzilla 37848: When no TTY is available, don't output to console
        have_tty=0
        if [ "`tty`" != "not a tty" ]; then
                have_tty=1
        fi

        # For Cygwin, switch paths to Windows format before running Java
        if $cygwin; then
            Java_HOME=`cygpath --absolute --windows "$Java_HOME"`
            JRE_HOME=`cygpath --absolute --windows "$JRE_HOME"`
            CATALINA_HOME=`cygpath --absolute --windows "$CATALINA_HOME"`
            CATALINA_BASE=`cygpath --absolute --windows "$CATALINA_BASE"`
            CATALINA_TMPDIR=`cygpath --absolute --windows "$CATALINA_TMPDIR"`
            CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
            Java_ENDORSED_DIRS=`cygpath --path --windows "$Java_ENDORSED_DIRS"`
        fi

        # Set juli LogManager config file if it is present and an override has not been issued
        if [ -z "$LOGGING_CONFIG" ]; then
            if [ -r "$CATALINA_BASE"/conf/logging.properties ]; then
                LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"
            else
                # Bugzilla 45585
                LOGGING_CONFIG="-Dnop"
            fi
        fi

        if [ -z "$LOGGING_MANAGER" ]; then
            Java_OPTS="$Java_OPTS -Djava.util.logging.manager=org.Apache.juli.ClassLoaderLogManager"
        else
            Java_OPTS="$Java_OPTS $LOGGING_MANAGER"
        fi

        # ----- Execute The Requested Command -----------------------------------------

        # Bugzilla 37848: only output this if we have a TTY
        if [ $have_tty -eq 1 ]; then
            echo "Using CATALINA_BASE:   $CATALINA_BASE"
            echo "Using CATALINA_HOME:   $CATALINA_HOME"
            echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR"
            if [ "$1" = "debug" ] ; then
                echo "Using Java_HOME:       $Java_HOME"
            else
                echo "Using JRE_HOME:        $JRE_HOME"
            fi
            echo "Using CLASSPATH:       $CLASSPATH"
            if [ ! -z "$CATALINA_PID" ]; then
                # Added by Jignesh Gohel - Nov 08, 2011.

                # There was an issue occuring when shutting down Tomcat using 
                # command ./catalina.sh stop

                # Issue mentioned at : http://stackoverflow.com/questions/7890197/facing-some-issues-regarding-Tomcat-startup-and-shutdown-on-ubuntu-10-04

                # Tomcat was shutting down properly but the process started using 
                # command ./catalina.sh start was not getting killed.

                # To resolve this issue following steps taken :-

                # 1) Exported an environment variable named CATALINA_PID which 
                # should point to a file in which the Tomcat process id would be 
                # written.

                # Note: Using the normal command to shutdown Tomcat "./catalina.sh stop" 
                # following message was logged "Tomcat did not stop in time. PID file 
                # was not removed".Thus to shutdown the Tomcat using following command
                # "./catalina.sh stop -force" which forcefully kills the Tomcat process
                # and also removes the file pointed by environment variable 
                # "$CATALINA_PID".Thus executing a "touch" command when starting up
                # Tomcat to automatically create the file.

                touch "$CATALINA_PID"
                echo "Using CATALINA_PID:    $CATALINA_PID"
            fi
        fi

        if [ "$1" = "jpda" ] ; then
            if [ -z "$JPDA_TRANSPORT" ]; then
                JPDA_TRANSPORT="dt_socket"
            fi
            if [ -z "$JPDA_ADDRESS" ]; then
                JPDA_ADDRESS="8000"
            fi
            if [ -z "$JPDA_SUSPEND" ]; then
                JPDA_SUSPEND="n"
            fi
            if [ -z "$JPDA_OPTS" ]; then
                JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND"
            fi
            CATALINA_OPTS="$CATALINA_OPTS $JPDA_OPTS"
            shift
        fi

        if [ "$1" = "debug" ] ; then
            if $os400; then
                echo "Debug command not available on OS400"
                exit 1
            else
                shift
                if [ "$1" = "-security" ] ; then
                    if [ $have_tty -eq 1 ]; then
                        echo "Using Security Manager"
                    fi
                    shift
                    exec "$_RUNJDB" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                        -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                        -sourcepath "$CATALINA_HOME"/../../Java \
                        -Djava.security.manager \
                        -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
                        -Dcatalina.base="$CATALINA_BASE" \
                        -Dcatalina.home="$CATALINA_HOME" \
                        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                        org.Apache.catalina.startup.Bootstrap "$@" start
                else
                    exec "$_RUNJDB" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                        -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                        -sourcepath "$CATALINA_HOME"/../../Java \
                        -Dcatalina.base="$CATALINA_BASE" \
                        -Dcatalina.home="$CATALINA_HOME" \
                        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                        org.Apache.catalina.startup.Bootstrap "$@" start
                fi
            fi

        Elif [ "$1" = "run" ]; then

            shift
            if [ "$1" = "-security" ] ; then
                if [ $have_tty -eq 1 ]; then
                    echo "Using Security Manager"
                fi
                shift
                exec "$_RUNJAVA" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                    -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                    -Djava.security.manager \
                    -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
                    -Dcatalina.base="$CATALINA_BASE" \
                    -Dcatalina.home="$CATALINA_HOME" \
                    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                    org.Apache.catalina.startup.Bootstrap "$@" start
            else
                exec "$_RUNJAVA" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                    -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                    -Dcatalina.base="$CATALINA_BASE" \
                    -Dcatalina.home="$CATALINA_HOME" \
                    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                    org.Apache.catalina.startup.Bootstrap "$@" start
            fi

        Elif [ "$1" = "start" ] ; then

            if [ ! -z "$CATALINA_PID" ]; then
                if [ -f "$CATALINA_PID" ]; then
                    if [ -s "$CATALINA_PID" ]; then
                        echo "Existing PID file found during start."
                        if [ -r "$CATALINA_PID" ]; then
                            PID=`cat "$CATALINA_PID"`
                            ps -p $PID >/dev/null 2>&1
                            if [ $? -eq 0 ] ; then
                                echo "Tomcat appears to still be running with PID $PID. Start aborted."
                                exit 1
                            else
                                echo "Removing/clearing stale PID file."
                                rm -f "$CATALINA_PID" >/dev/null 2>&1
                                if [ $? != 0 ]; then
                                    if [ -w "$CATALINA_PID" ]; then
                                        cat /dev/null > "$CATALINA_PID"
                                    else
                                        echo "Unable to remove or clear stale PID file. Start aborted."
                                        exit 1
                                    fi
                                fi
                            fi
                        else
                            echo "Unable to read PID file. Start aborted."
                            exit 1
                        fi
                    else
                        rm -f "$CATALINA_PID" >/dev/null 2>&1
                        if [ $? != 0 ]; then
                            if [ ! -w "$CATALINA_PID" ]; then
                                echo "Unable to remove or write to empty PID file. Start aborted."
                                exit 1
                            fi
                        fi
                    fi
                fi
            fi

            shift
            touch "$CATALINA_OUT"
            if [ "$1" = "-security" ] ; then
                if [ $have_tty -eq 1 ]; then
                    echo "Using Security Manager"
                fi
                shift
                "$_RUNJAVA" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                    -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                    -Djava.security.manager \
                    -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
                    -Dcatalina.base="$CATALINA_BASE" \
                    -Dcatalina.home="$CATALINA_HOME" \
                    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                    org.Apache.catalina.startup.Bootstrap "$@" start \
                    >> "$CATALINA_OUT" 2>&1 &

            else
                "$_RUNJAVA" "$LOGGING_CONFIG" $Java_OPTS $CATALINA_OPTS \
                    -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                    -Dcatalina.base="$CATALINA_BASE" \
                    -Dcatalina.home="$CATALINA_HOME" \
                    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                    org.Apache.catalina.startup.Bootstrap "$@" start \
                    >> "$CATALINA_OUT" 2>&1 &

            fi

            if [ ! -z "$CATALINA_PID" ]; then
                echo $! > "$CATALINA_PID"
            fi

        Elif [ "$1" = "stop" ] ; then

            shift

            SLEEP=5
            if [ ! -z "$1" ]; then
                echo $1 | grep "[^0-9]" >/dev/null 2>&1
                if [ $? -gt 0 ]; then
                    SLEEP=$1
                    shift
                fi
            fi

            FORCE=0
            if [ "$1" = "-force" ]; then
                shift
                FORCE=1
            fi

            if [ ! -z "$CATALINA_PID" ]; then
                if [ -s "$CATALINA_PID" ]; then
                    if [ -f "$CATALINA_PID" ]; then
                        kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
                        if [ $? -gt 0 ]; then
                            echo "PID file found but no matching process was found. Stop aborted."
                            exit 1
                        fi
                    else
                        echo "\$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted."
                        exit 1
                    fi
                else
                    echo "PID file is empty and has been ignored."
                fi
            fi

            "$_RUNJAVA" $Java_OPTS \
                -Djava.endorsed.dirs="$Java_ENDORSED_DIRS" -classpath "$CLASSPATH" \
                -Dcatalina.base="$CATALINA_BASE" \
                -Dcatalina.home="$CATALINA_HOME" \
                -Djava.io.tmpdir="$CATALINA_TMPDIR" \
                org.Apache.catalina.startup.Bootstrap "$@" stop

            if [ ! -z "$CATALINA_PID" ]; then
                if [ -f "$CATALINA_PID" ]; then
                    while [ $SLEEP -ge 0 ]; do
                        kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
                        if [ $? -gt 0 ]; then
                            rm -f "$CATALINA_PID" >/dev/null 2>&1
                            if [ $? != 0 ]; then
                                if [ -w "$CATALINA_PID" ]; then
                                    cat /dev/null > "$CATALINA_PID"
                                else
                                    echo "Tomcat stopped but the PID file could not be removed or cleared."
                                fi
                            fi
                            break
                        fi
                        if [ $SLEEP -gt 0 ]; then
                            sleep 1
                        fi
                        if [ $SLEEP -eq 0 ]; then
                            if [ $FORCE -eq 0 ]; then
                                echo "Tomcat did not stop in time. PID file was not removed."
                            fi
                        fi
                        SLEEP=`expr $SLEEP - 1 `
                    done
                fi
            fi

            if [ $FORCE -eq 1 ]; then
                if [ -z "$CATALINA_PID" ]; then
                    echo "Kill failed: \$CATALINA_PID not set"
                else
                    if [ -f "$CATALINA_PID" ]; then
                        PID=`cat "$CATALINA_PID"`
                        echo "Killing Tomcat with the PID: $PID"
                        kill -9 $PID
                        rm -f "$CATALINA_PID" >/dev/null 2>&1
                        if [ $? != 0 ]; then
                            echo "Tomcat was killed but the PID file could not be removed."
                        fi
                    fi
                fi
            fi

        Elif [ "$1" = "version" ] ; then

                "$_RUNJAVA"   \
                    -classpath "$CATALINA_HOME/lib/catalina.jar" \
                    org.Apache.catalina.util.ServerInfo

        else

            echo "Usage: catalina.sh ( commands ... )"
            echo "commands:"
            if $os400; then
                echo "  debug             Start Catalina in a debugger (not available on OS400)"
                echo "  debug -security   Debug Catalina with a security manager (not available on OS400)"
            else
                echo "  debug             Start Catalina in a debugger"
                echo "  debug -security   Debug Catalina with a security manager"
            fi
            echo "  jpda start        Start Catalina under JPDA debugger"
            echo "  run               Start Catalina in the current window"
            echo "  run -security     Start in the current window with security manager"
            echo "  start             Start Catalina in a separate window"
            echo "  start -security   Start in a separate window with security manager"
            echo "  stop              Stop Catalina, waiting up to 5 seconds for the process to end"
            echo "  stop n            Stop Catalina, waiting up to n seconds for the process to end"
            echo "  stop -force       Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running"
            echo "  stop n -force     Stop Catalina, wait up to n seconds and then use kill -KILL if still running"
            echo "  version           What version of Tomcat are you running?"
            echo "Note: Waiting for the process to end and use of the -force option require that \$CATALINA_PID is defined"
            exit 1

        fi

おかげで、

ジニェシュ

1
Jignesh Gohel

/etc/bash.bashrcを使用しないでください。これをcatalina.shに置くだけです

後:

if [ -r "$CATALINA_BASE"/bin/setenv.sh ]; then
            . "$CATALINA_BASE"/bin/setenv.sh
        Elif [ -r "$CATALINA_HOME"/bin/setenv.sh ]; then
            . "$CATALINA_HOME"/bin/setenv.sh
        fi

これを入れて:

export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt"

そして、catalina.sh stop -forceを使用すると、Tomcatが強制終了されます。

13
Steven Lizarazo

解決;最初にTomcatのpidを設定しますCATALINA_PID = "/ id.pid" export CATALINA_PID

それを殺しますcatalina.sh stop -force

ソース: http://confluence.atlassian.com/pages/viewpage.action?pageId=216959212

さもなければ、あなたが言ったように、killコマンドでそれを殺してください

ps aux | grep catalina
kill <pid of Tomcat>

上記の2つのソリューションがニーズに合わない場合は、以下を試してください:

$ Sudo service Tomcat6 stop
* Stopping Tomcat servlet engine Tomcat6 [ OK ]
$ Sudo service Tomcat6 start
* Starting Tomcat servlet engine Tomcat6 [ OK ]
$

またはもちろん、より伝統的な方法:

$ Sudo /etc/init.d/Tomcat6 stop
* Stopping Tomcat servlet engine Tomcat6 [ OK ]
$ Sudo /etc/init.d/Tomcat6 start
* Starting Tomcat ser
2
Ben

この問題に対する私のシナリオでは、Tomcatに投稿されたシャットダウンメッセージで正常に終了しなかったスレッドがいくつかあり、Tomcatプロセスがまだ動き回っていました。

ですから、単純なTomcatインスタンスから始めて、カスタムの「wars」または変更を1つずつ追加し続け、Tomcatを正常に停止して問題を絞り込みます。

0
praveen adupa

次のコマンドはトリックを行います:

service Tomcat8 stop

これらも役立ちます:

service Tomcat8 start
service Tomcat8 restart
0
Josafat

(catalina.shのインラインコメントによる)公式に推奨される方法は次のとおりです。

  • $ CATALINA_HOME/binの下にsetenv.shファイルを作成します。

#!/ bin/sh

CATALINA_PID = "$ CATALINA_HOME/logs/catalina.pid"; CATALINA_PIDをエクスポート

  • 実行可能ファイルとしてのchmod:

    chmod u + x setenv.sh

  • pidファイルを作成するには:

    $ CATALINA_HOME/logs/catalina.pidをタッチします

  • その後、通常どおりTomcatを起動すると、pidファイルが自動的に更新されます。また、「-force」オプションでTomcatを停止することもできます。
0
Tomofumi

この問題は、Tomcatを(通常モードまたはデバッグモードで)起動するために使用するアドレスが既に別のプロセスによって使用されているために発生します。

You confファイル(例:your_Tomcat_HOME_DIR_/conf/server.xml)で使用しているポートを確認して、まだ使用されていないかどうかを確認する必要があります

ここで使用するポートを見ることができます

  • tomcatの開始:デフォルト値8080
  • tomcatの停止:デフォルト値8005
  • aJPプロトコルで使用:デフォルト値8009

tomcatをデバッグモードで使用している場合(jdpaまたはjdwpを使用)、以前に設定されたすべてのポートとは異なるポートを使用するようにしてください

0
arthur