Het grote "handige scripts" topic

[Osiris]

CyBeR schreef op zondag 05 augustus 2012 @ 16:03:
[...]


Excuseer. Ik bedoelde eigenlijk het volgende:

$mkdir foo\ 1
$mkdir foo\ 2
$mkdir foo_3
$ls foo<tab>
foo 1/ foo 2/ foo_3/ 
$ls foo\ <tab>
foo 1/ foo 2/ 

Ah, tja, dán wel ja. Dan moet je d'r ff een slash voorzetten.

Maargoed, in dat geval zul je *sowieso* een teken moeten zetten. En bij een spatie een heuse backslash ervoor, whooptiedoo Gaat bij mij al automagisch met m'n rechterpink

[ Voor 127% gewijzigd door Osiris op 05-08-2012 16:19 ]

[DiedB]

Osiris schreef op zondag 05 augustus 2012 @ 16:03:
Aangezien het een "verdekt opgestelde" spam-URL is voor iedereen hier:

Bovenstaande is een spammer en die goo.gl-URL linkt naar "zijn site". Kortom, niet op klikken!

Ow, nieuwe pagina, nog beter, dan ziet niemand de URL meer
[...]

Ah, tja, dán wel ja. Dan moet je d'r ff een slash voorzetten.

Een mod haalt het er snel genoeg af en zal de user permabannen. Heb zo'n zielige manier van reclame maken nog niet gezien...

[Hero of Time]

Mensen, een TR is vele malen beter dan in je post te melden dat er een spammer is. Off-topic reageren dat er een spammer is, is al helemaal niet de bedoeling.

[CyBeR]

Osiris schreef op zondag 05 augustus 2012 @ 16:03:
[...]

Ah, tja, dán wel ja. Dan moet je d'r ff een slash voorzetten.

Maargoed, in dat geval zul je *sowieso* een teken moeten zetten. En bij een spatie een heuse backslash ervoor, whooptiedoo Gaat bij mij al automagisch met m'n rechterpink

Ja mijn idee, daarom vroeg ik me af waarom dinges er zo'n enorm script voor heeft gemaakt

[Anoniem: 76181]

Naam: pls
Doel: hetzelfde als "ls -la", maar dan doet ie file permissies octaal
Werking: pls /path/to/dir/or/file/or/nothing
OS: *nix Taal: ksh
Configuratie: nvt
Parameters: nvt
Opmerkingen: Staat ook op http://www.peterharnisch.nl/pls/ ; Vaak wordt er om deze functionaliteit gevraagd, maar ik heb er verder nog nooit iets voor gevonden. Vandaar zelf geschreven. Maar als er hier een commandootje voor is hoor ik het graag! :-)

code:

#!/usr/bin/ksh
#because ksh > bash
#Written by Peter Harnisch

ls -la $* | while read a
do
  perms=`echo ${a} | cut -d' ' -f1`
  rest=`echo ${a} | cut -d' ' -f2-`

  stickybits=`echo ${perms} | cut -c4,7,10 | tr 'Ssx-' '1100'`
  otherperms=`echo ${perms} | cut -c2- | tr 'rwxsS-' '111100'`
  perms=`echo ibase=2\;obase=8\;${stickybits}${otherperms} | bc`
  echo ${perms} ${rest}
done

[Anoniem: 294759]

Anoniem: 294759 schreef op zaterdag 21 juli 2012 @ 16:25:
Dit is een "gehackte" versie van het start/stop script 'catalina.sh' van Tomcat 6(!)

Naam: catalina.sh
Doel: Het starten en stoppen van een Tomcat 6 proces. Verschil is dat Tomcat van origine niet de mogelijkheid heeft om meerdere instances aan te maken die je ook nog eens afzonderlijk kunnen stoppen en starten.
OS: Getest op CentOS.
Taal: bash
Werking: om het script te laten werken heb je de volgende stappen doen:

• Ga naar de installatie folder van Tomcat.
• Pak alles in met een tar -zcf
• Maak een map aan genaamd "instances" in de Tomcat map
• Maak daarna mappen wat evenredig is aan het aantal instances wat jij wilt hebben op 1 server(wat meestal neerkomt op zo'n 2 a 3 mappen, afhankelijk van de zwaarte van de applicaties) met de gewenste "instance name" zoals "app_srv_1"
• Ga in een van die mappen en pak het bestand uit die in de tweede stap is aangemaakt in de folder
• Pas in het script variabel TOMCAT_HOME en INSTANCE_NAME aan en plaats het in de root van de instance folder
• Mocht het gelukt zijn: verwijder de "bin" map uit de instance map.

*SNIP oude code*

Dit is een "gehackte" versie van het start/stop script 'catalina.sh' van Tomcat 6(!)

Naam: catalina.sh
Doel: Het starten en stoppen van een Tomcat 6 proces. Verschil is dat Tomcat van origine niet de mogelijkheid heeft om meerdere instances aan te maken die je ook nog eens afzonderlijk kunnen stoppen en starten.
OS: Getest op CentOS en Redhat Enterprise Linux
Taal: bash
Werking: om het script te laten werken heb je de volgende stappen doen:

• Maak een user en group aan genaamd "tomcat"
• Maak een folder genaamd "tomcat" in /var/run en geef de map alleen rechten aan user "tomcat"
• Ga naar de installatie folder van Tomcat.
• Pak alles in met een tar -zcf
• Maak een map aan genaamd "instances" in de Tomcat map
• Maak daarna mappen wat evenredig is aan het aantal instances wat jij wilt hebben op 1 server(wat meestal neerkomt op zo'n 2 a 3 mappen, afhankelijk van de zwaarte van de applicaties) met de gewenste "instance name" zoals "app_srv_1"
• Ga in een van die mappen en pak het bestand uit die in de tweede stap is aangemaakt in de folder
• Pas in het script variabel TOMCAT_HOME en INSTANCE_NAME aan en plaats het in de root van de instance folder
• Verander ownership recursief vanaf de root van de tomcat installatie map naar "tomcat"
• Mocht het gelukt zijn: verwijder de "bin" map uit de instance map.

Veranderingen:
- In het script wordt er nu afgedwongen dat alleen user "tomcat" recht heeft om tomcat te gebruiken
- locatie van de PID bestanden worden nu geplaatst in een aparte map in '/var/run'
- Kleine formattering veranderingen

code:

#!/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 1146097 2011-07-13 15:25:05Z markt $
# -----------------------------------------------------------------------------

# Verander mij!!!
JAVA_HOME=/usr/java/latest
TOMCAT_INSTALL=/opt/tomcat
INSTANCE_NAME=inst_1

# Onderstaande niet veranderen!!!
CATALINA_PID_DIR=/var/run/tomcat
CATALINA_HOME="$TOMCAT_INSTALL"
CATALINA_BASE="$CATALINA_HOME"/instances/"$INSTANCE_NAME"
CATALINA_OUT="$TOMCAT_INSTALL"/instances/"$INSTANCE_NAME"/logs/catalina.out
CATALINA_TMPDIR="$TOMCAT_INSTALL"/instances/"$INSTANCE_NAME"/temp
CATALINA_PID=$CATALINA_PID_DIR/"$INSTANCE_NAME".pid
LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"

# 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=$TOMCAT_INSTALL

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

# Copy CATALINA_BASE from CATALINA_HOME if not already set
[ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"

# 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=

# Get standard Java environment variables
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

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 [ -d "$CATALINA_HOME" ] && [ -r "$CATALINA_HOME/bin/tomcat-juli.jar" ] ; then
  CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/tomcat-juli.jar:"$CATALINA_HOME"/bin/bootstrap.jar
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

# 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
  if [ ! `whoami` = "tomcat" ] ; then
    echo "You do not have enough privileges."
    exit 1
  fi
  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
    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
    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
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 [ ! -d $CATALINA_PID_DIR ] ; then
     echo "Cannot create PID file in $CATALINA_PID_DIR. Start aborted."
     exit 1
  fi
  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 [ ! -d $CATALINA_PID_DIR ] ; then
     echo "Cannot create PID file in $CATALINA_PID_DIR. Stop aborted."
     exit 1
  fi
  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 [ ! -d $CATALINA_PID_DIR ] ; then
     echo "Cannot create PID file in $CATALINA_PID_DIR. Stop aborted."
     exit 1
  fi
  if [ ! -z "$CATALINA_PID" ]; then
    if [ -f "$CATALINA_PID" ]; then
      if [ -s "$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 "PID file is empty and has been ignored."
      fi
    else
      echo "\$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted."
      exit 1
    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: $INSTANCE_NAME.sh ( commands ... )"
  echo "commands:"
  echo "  debug             Start Tomcat in a debugger"
  echo "  debug -security   Debug Tomcat with a security manager"
  echo "  jpda start        Start Tomcat under JPDA debugger"
  echo "  run               Start Tomcat in the current window"
  echo "  run -security     Start in the current window with security manager"
  echo "  start             Start Tomcat in a separate window"
  echo "  start -security   Start in a separate window with security manager"
  echo "  stop              Stop Tomcat, waiting up to 5 seconds for the process to end"
  echo "  stop n            Stop Tomcat, waiting up to n seconds for the process to end"
  echo "  stop -force       Stop Tomcat, wait up to 5 seconds and then use kill -KILL if still running"
  echo "  stop n -force     Stop Tomcat, 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