[Mac]: Tomcat und Apache verknüpfen mit Autostart

In diesem Post wird beschrieben, wie man auf seinem Mac einen Tomcat mit Autostart einrichtet und die Aufrufe über einen Apache Webserver an Tomcat weiterleiten lassen kann.

Einrichtung Tomcat

Auf aktuellen Macs ist standardmässig ein Apache 2 installiert. Dieser wird hier als Webserver genutzt.

Folgende Schritte sind zum Einrichten notwendig:

  1. Unter http://tomcat.apache.org/ eine passende Tomcat-Version herunterladen.
  2. Das heruntergeladene Archiv entpacken und das Verzeichnis nach „/Applications“ verschieben.
  3. Terminal öffnen und einen softlink auf das Tomcat-Verzeichnis erzeugen. Z.B.: „ln -s /Applications/apache-tomcat-7.0.6 /Applications/tomcat“
  4. Jetzt die Umgebungsvariablen für Tomcat setzen. Mit dem Editor seines Vertrauens (bei mir joe im Terminal) die Profildatei öffnen:
    „joe ~/.profile“
  5. Folgende Einträge einfügen:
    export JAVA_HOME=/Library/Java/Home
    export CATALINA_HOME=/Applications/tomcat
  6. Im Terminal ins Verzeichnis „/Applications/tomcat/bin“ wechseln und „./startup.sh“ ausführen und damit testen, ob Tomcat startet. Sollte es einen Permissionfehler geben, „chmod 755 /Applications/tomcat/bin/*.sh“ ausführen.
  7. Tomcat kann jetzt wieder mit „./shutdown.sh“ gestoppt werden.
  8. Um Zugriff auf die Manager-Oberfläche des Tomcats zu erlangen, fügt man in der Datei /Applications/tomcat/conf/tomcat-users.xml zwischen <tomcat-users></tomcat-users> folgendes ein:
    <user username=“yourmanageruser“ password=“asecretpassword“ roles=“manager-gui“ />

Damit läuft erstmal der Tomcat, muss aber noch manuell gestartet und gestoppt werden. Nächster Schritt ist die Einrichtung des Autostarts.

Autostart Tomcat

Mit dem Editor des Vertrauens die Datei „/Applications/tomcat/bin/launchd_wrapper.sh“ anlegen:

#!/bin/bash
function shutdown()
{
   date
   echo "Shutting down Confluence"
   $CATALINA_HOME/bin/catalina.sh stop
}
date
echo "Starting Confluence"
export CATALINA_PID=/tmp/$$

# Uncomment to increase Tomcat's maximum heap allocation
# export JAVA_OPTS=-Xmx512M $JAVA_OPTS
. $CATALINA_HOME/bin/catalina.sh start

# Allow any signal which would kill a process to stop Tomcat
trap shutdown HUP INT QUIT ABRT KILL ALRM TERM TSTP

echo "Waiting for `cat $CATALINA_PID`"
wait `cat $CATALINA_PID`
Zum Testen dieses Skript mit „/Applications/tomcat/bin/launchd_wrapper.sh“ aufrufen…es sollte sich NICHT selbst beenden. Mit Ctrl+C kann Tomcat wieder beendet werden.

Nun als „root“-User die Datei „/Library/LaunchDaemons/tomcat.plist“ anlegen:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
        <key>Disabled</key>
        <false/>
        <key>EnvironmentVariables</key>
        <dict>
                <key>CATALINA_HOME</key>
                <string>/Applications/tomcat</string>
                <key>JAVA_HOME</key>
                <string>/Library/Java/Home</string>
        </dict>
        <key>Label</key>
        <string>Tomcat</string>
        <key>OnDemand</key>
        <false/>
        <key>ProgramArguments</key>
        <array>
                <string>/Applications/tomcat/bin/launchd_wrapper.sh</string>
        </array>
        <key>RunAtLoad</key>
        <true/>
        <key>ServiceDescription</key>
        <string>Tomcat</string>
        <key>StandardErrorPath</key>
        <string>/Applications/tomcat/logs/launchd.stderr</string>
        <key>StandardOutPath</key>
        <string>/Applications/tomcat/logs/launchd.stdout</string>
        <key>UserName</key>
        <string>root</string>
</dict>
</plist>

Starten kann man den Tomcat-Service im Verzeichnis „/Library/LaunchDaemons/“ nun per:

"sudo launchctl load -w tomcat.plist"

Beendet wird der Tomcat-Service per:

"sudo launchctl unload -w tomcat.plist"

Tomcat sollte jetzt beim Starten des Macs von selbst hochfahren. Fehlt noch die Verknüpfung von Apache und Tomcat.

Verknüpfung Tomcat und Apache

Als „root“ mit einem Editor die Datei „/etc/apache2/other/tomcat.conf“ anlegen:

ProxyPass / http://localhost:8080/ ProxyPassReverse / http://localhost:8080/

Jetzt noch mal den Apachen durchstarten:

"sudo apachectl graceful"

Jetzt sollte Tomcat über den Apachen ausgeliefert werden. Ein Test im Browser sollte mit „http://localhost/“ funktionieren.

Quellen:
————

[Android]: Aufrufen einer Activity und dabei Daten mit übergeben

Beim Aufrufen einer Activity kann man Daten übergeben, die in der aufgerufenen Activity ausgewertet werden können. Dies können primitive Datentypen sein oder Instanzen von eigenen Klassen.

Der Aufrufer muss eine Intent-Instanz mit den entsprechenden Informationen befüllen und mit diesem Intent dann die Activity aufrufen.

01.   Intent intent = new Intent( context, YourActivityClass.class );
02.   YourContainerClass data = new YourContainerClass( „some usefull data“ );
03.   intent.putExtra( „yourdata“, data );
04.   startActivity( intent );

In Zeile 01 wird eine Intent-Instanz erzeugt. Die Activity-Klasse, die aufgerufen werden soll, heisst hier YourActivityClass.

In Zeile 02 wird von einer Klasse eine Instanz erzeugt, die als Datencontainer dient und die benötigten Informationen vom Aufrufer an YourActivityClass übergibt. Im Beispiel wird davon ausgegangen, dass der String „some usefull data“ innerhalb der Container-Instanz gespeichert wird und dadurch an YourActivityClass übergeben wird.

In Zeile 03 wird die Instanz der Container-Klasse in die Intent-Instanz übergeben. Die Container-Klasse wird dabei unter dem Schlüssel „yourdata“ abgelegt.

In Zeile 04 wird schliesslich die Activity (hier also YourActivityClass) aufgerufen.

Um die Informationen auf Seiten der aufgerufenen Activity auszulesen, wird folgender Code genutzt:

01.    protected void onCreate( Bundle savedInstanceState )
02.    {
03.        super.onCreate( savedInstanceState );
04.        Intent intent = getIntent();
05.        YourContainerClass data = ( YourContainerClass )intent.getExtras().get( „yourdata“ );
06.        // doing some other usefull stuff
07.    }

In Zeile 01 wird der Methodenaufruf von onCreate() gezeigt, möglich wäre aber z.B. auch onStart() oder onResume().

In Zeile 04 wird das Intent-Objekt geholt, welches zum Aufruf der Activity genutzt wurde.

In Zeile 05 wird die Container-Klasse aus dem Intent-Objekt geholt, welches auf Seiten des Aufrufer-Codes unter dem Schlüssel „yourdata“ in dem Intent-Objekt abgelegt wurde.