Đối mặt với một số vấn đề liên quan đến khởi động và tắt máy tomcat trên ubuntu 10.04

Question

Tôi đang gặp một số vấn đề liên quan đến khởi động và tắt máy tomcat.

Tôi đang sử dụng

1. Tomcat v.6.0.32 (sử dụng chiết xuất gói tải về từ trang web của Apache và không phải là người phân phối bởi Ubuntu 10.04)
2. Ubuntu v.10.04

Tôi bắt đầu lệnh tomcat bằng cách sử dụng lệnh:

$./catalina.sh jpda start 

Sau đó, tôi thử dừng bằng lệnh :

$./catalina.sh stop 

và nhận được thông báo sau:

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) 

Tôi cũng đã cố gắng ngăn chặn nó sử dụng lệnh:

$./catalina.sh stop -force 

nhưng tôi nhận được tin nhắn:

Kill failed: $CATALINA_PID not set 

Sau đó, Tôi lại cố gắng bắt đầu sử dụng tomcat lệnh:

$./catalina.sh jpda start 

Trong/bản ghi thư mục chỉ catalina.out được tạo ra với thông báo lỗi sau:

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) 

Vì nó được nêu trong báo lỗi "Address already in use" Tôi xác nhận không có ứng dụng khác được cấu hình để chạy trên cổng 8080. Mỗi khi tôi giết quá trình id và khởi động lại nó, khởi động hoạt động tốt. Điều này yêu cầu tôi phải giết quá trình theo cách thủ công bằng lệnh "KILL", khi tôi cần dừng máy chủ tomcat. Hành vi tương tự này mà tôi đang gặp phải trên các máy khác cũng có cùng môi trường như đã đề cập ở trên được thiết lập.

Ai có thể vui lòng cho tôi biết nguyên nhân gây ra vấn đề này và cách giải quyết vấn đề này?

Cảm ơn,
Jignesh

Answer 1

Cố định tắt máy tomcat issue.Posting giải pháp ở đây để tham khảo.

làm như sau để khắc phục nó trên máy tính của bạn:

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 - chứa inline của tôi bình luận

 #!/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 

Cảm ơn,

Jignesh

Answer 2

Vấn đề là gây ra bởi vì địa chỉ mà bạn sử dụng để bắt đầu tomcat (trong chế độ bình thường hoặc debug) đã được sử dụng bởi quá trình khác.

Bạn cần kiểm tra các cổng bạn đang sử dụng trong tệp conf của bạn (ví dụ: your_TOMCAT_HOME_DIR_/conf/server.xml), để xem nếu chúng chưa được sử dụng

đây bạn có thể nhìn vào các cổng được sử dụng cho

• bắt đầu Tomcat: giá trị mặc định 8080
• dừng Tomcat: giá trị mặc định 8005
• sử dụng với AJP protocoll: giá trị mặc định 8009

và nếu bạn đang sử dụng Tomcat trong chế độ gỡ lỗi (thông qua jdpa hoặc jdwp), hãy chắc chắn để sử dụng một cổng khác với tất cả các cấu hình cổng trước

Answer 3

Trong trường hợp của tôi cho vấn đề này, đã có một số chủ đề không chấm dứt thành công với thông điệp tắt được đăng lên tomcat, mà làm cho quá trình tomcat vẫn treo xung quanh.

Vì vậy, tôi sẽ bắt đầu với trường hợp tomcat đơn giản..và tiếp tục thêm "chiến tranh" tùy chỉnh hoặc thay đổi từng cái một và đảm bảo dừng tomcat thành công để thu hẹp sự cố.

Answer 4

Giải pháp; Đầu tiên thiết lập pid của tomcat CATALINA_PID = "/ id.pid" xuất khẩu CATALINA_PID

sau đó giết nó catalina.sh dừng -force

nguồn: http://confluence.atlassian.com/pages/viewpage.action?pageId=216959212

khác cũng giống như bạn đã đề cập, chỉ cần giết nó với lệnh giết

ps aux | grep catalina 
kill <pid of tomcat> 

nếu hai giải pháp trên không phù hợp với nee của bạn ds thử như sau:

$ sudo service tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo service tomcat6 start 
* Starting Tomcat servlet engine tomcat6 [ OK ] 
$ 

hoặc tất nhiên theo cách truyền thống hơn:

$ sudo /etc/init.d/tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo /etc/init.d/tomcat6 start 
* Starting Tomcat ser 

Answer 5

Dont sử dụng /etc/bash.bashrc.210 chỉ cần đặt này trên catalina.sh

của bạn Sau:

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 

đặt này:

export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt" 

Và bây giờ tomcat của bạn sẽ bị giết khi bạn sử dụng catalina.sh dừng -force

Answer 6

Tôi nghĩ rằng cách chính thức đề xuất (theo catalina.sh comments inline) là:

• tạo một file setenv.sh dưới $ CATALINA_HOME/bin:

#!/Bin/sh

CATALINA_PID = "$ CATALINA_HOME/logs/catalina.pid"; xuất khẩu CATALINA_PID

• chmod như thực thi:

  chmod u + x setenv.sh

• tạo tập tin pid bởi:

  touch $ CATALINA_HOME/logs/catalina .pid

• sau đó khởi động tomcat như thường lệ, tệp pid sẽ được cập nhật tự động. Và bạn cũng có thể dừng tomcat bằng tùy chọn "-force".

Answer 7

Sau lệnh hiện các trick:

service tomcat8 stop

Những người sẽ là hữu ích quá:

service tomcat8 start

service tomcat8 restart