EC2 Server Deployment and Troubleshooting

EC2_RDS_INSTANCE_TYPE=db.m1.small
EC2_RDS_SECURITY_GROUP=kfs-rds-servers
EC2_OWNER_ID=${KFS_EC2_OWNER}
EC2_RDS_PARAMETER_GROUP=kfs-parameter-group
EC2_AVAILABILITY_ZONE=us-east-1b
EC2_RDS_KFS_ADMIN_USER=${RDS_ADMIN_USER}
EC2_RDS_KFS_ADMIN_PASSWORD=${RDS_ADMIN_PW}

INSTANCE_NAME=kfs-${INSTANCE}

mkdir -p $INSTANCE_NAME

echo Checking for an existing instance for this service: $INSTANCE_NAME
OLD_STATUS=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f 8 -d ,`
if [ "$OLD_STATUS" = "available" ]; then
    echo An Instance for $INSTANCE_NAME is already running:
    rds-describe-db-instances $INSTANCE_NAME
	exit 0;
fi
echo No Existing instances running with this name - proceeding with launch

rds-create-db-instance $INSTANCE_NAME \
--allocated-storage 5 \
--db-instance-class ${EC2_RDS_INSTANCE_TYPE} \
--engine MySQL5.1 \
--backup-retention-period 0 \
--master-username $EC2_RDS_KFS_ADMIN_USER \
--master-user-password $EC2_RDS_KFS_ADMIN_PASSWORD \
--availability-zone $EC2_AVAILABILITY_ZONE \
--db-parameter-group-name $EC2_RDS_PARAMETER_GROUP \
--db-security-groups $EC2_RDS_SECURITY_GROUP

# Wait until the instance is available
echo Starting instance $INSTANCE_NAME - this takes a few minutes
DONE="false"
while [ "$DONE" = "false" ]
do
   STATUS=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f 8 -d ,`
   if [ "$STATUS" = "available" ]; then
      DONE="true"
   else
      echo Waiting...$STATUS
      sleep 10
   fi
done
echo $INSTANCE_NAME Is Available

EC2_RDS_KFS_ADMIN_USER=${RDS_ADMIN_USER}
EC2_RDS_KFS_ADMIN_PASSWORD=${RDS_ADMIN_PW}

BASEDIR=$WORKSPACE

INSTANCE_NAME=kfs-${INSTANCE}

RICE_DATA_DIR=$WORKSPACE/rice-cfg-dbs
#Generate the impex.properties file
EC2_RDS_HOST=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f9 -d,`
EC2_DB_URL=jdbc:mysql://${EC2_RDS_HOST}:3306

(
cat <<-EOF

    import.torque.database.user=$SCHEMA_NAME
    import.torque.database.schema=$SCHEMA_NAME
    import.torque.database.password=$SCHEMA_NAME

    torque.project=kfs
    torque.schema.dir=$RICE_DATA_DIR
    torque.sql.dir=\${torque.schema.dir}/sql
    torque.output.dir=\${torque.sql.dir}

    import.torque.database=mysql
    import.torque.database.driver=com.mysql.jdbc.Driver
    import.torque.database.url=${EC2_DB_URL}/$SCHEMA_NAME
    import.admin.user=$EC2_RDS_KFS_ADMIN_USER
    import.admin.password=$EC2_RDS_KFS_ADMIN_PASSWORD
    import.admin.url=$EC2_DB_URL

EOF
) > impex-build.properties

# Fix the case of the table names (since EC2 is case sensitive)
perl -pi -e 's/dbTable="([^"]*)"/dbTable="\U\1"/g' $RICE_DATA_DIR/graphs/*.xml
perl -pi -e 's/viewdefinition="([^"]*)"/viewdefinition="\U\1"/g' $RICE_DATA_DIR/schema.xml
perl -pi -e 's/&#[^;]*;/ /gi' $RICE_DATA_DIR/schema.xml

ant -Duser.home=$WORKSPACE -buildfile kul-cfg-dbs/impex/build.xml create-schema empty-schema import

BASEDIR=$WORKSPACE

INSTANCE_NAME=kfs-${INSTANCE}

IMPEX_TOOL_DIR=$WORKSPACE/kul-cfg-dbs
RICE_DATA_DIR=$WORKSPACE/rice-cfg-dbs
KFS_DIR=$WORKSPACE/kfs
LIQUIBASE_DIR=${KFS_DIR}/work/db/rice-data
WORKFLOW_DIR=${KFS_DIR}/work/workflow
#Generate the impex.properties file
EC2_RDS_HOST=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f9 -d,`
EC2_DB_URL=jdbc:mysql://${EC2_RDS_HOST}:3306

(
cat <<-EOF

    import.torque.database.user=$SCHEMA_NAME
    import.torque.database.schema=$SCHEMA_NAME
    import.torque.database.password=$SCHEMA_NAME

    torque.project=kfs
    torque.schema.dir=$RICE_DATA_DIR
    torque.sql.dir=\${torque.schema.dir}/sql
    torque.output.dir=\${torque.sql.dir}

	post.import.liquibase.project=kfs
	post.import.liquibase.xml.directory=$LIQUIBASE_DIR

	post.import.workflow.project=kfs
	post.import.workflow.xml.directory=$WORKFLOW_DIR
	post.import.workflow.ingester.launcher.ant.script=${KFS_DIR}/build.xml
	post.import.workflow.ingester.launcher.ant.target=import-workflow-xml
	post.import.workflow.ingester.launcher.ant.xml.directory.property=workflow.dir

	post.import.workflow.ingester.jdbc.url.property=datasource.url
	post.import.workflow.ingester.username.property=datasource.username
	post.import.workflow.ingester.password.property=datasource.password
	post.import.workflow.ingester.additional.command.line=-Ddatasource.ojb.platform=MySQL -Dbase.directory=$BASEDIR -Dexternal.config.directory=$BASEDIR -Dis.local.build= -Drice.ksb.batch.mode=true -Ddont.filter.project.rice= -Ddont.filter.project.spring.ide= -Ddont.filter.project.schema= -Ddev.mode=

    import.torque.database=mysql
    import.torque.database.driver=com.mysql.jdbc.Driver
    import.torque.database.url=${EC2_DB_URL}/$SCHEMA_NAME
    import.admin.user=$EC2_RDS_KFS_ADMIN_USER
    import.admin.password=$EC2_RDS_KFS_ADMIN_PASSWORD
    import.admin.url=$EC2_DB_URL

EOF
) > impex-build.properties

ant -Duser.home=$WORKSPACE -buildfile kul-cfg-dbs/impex/build.xml run-liquibase-post-import import-workflow

BASEDIR=$WORKSPACE

INSTANCE_NAME=kfs-${INSTANCE}

IMPEX_TOOL_DIR=$BASEDIR/kul-cfg-dbs
KFS_DATA_DIR=$BASEDIR/kfs-cfg-dbs
#Generate the impex.properties file
EC2_RDS_HOST=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f9 -d,`
EC2_DB_URL=jdbc:mysql://${EC2_RDS_HOST}:3306

(
cat <<-EOF
    import.torque.database.user=$SCHEMA_NAME
    import.torque.database.schema=$SCHEMA_NAME
    import.torque.database.password=$SCHEMA_NAME

    torque.project=kfs
    torque.schema.dir=$KFS_DATA_DIR
    torque.sql.dir=\${torque.schema.dir}/sql
    torque.output.dir=\${torque.sql.dir}

    import.torque.database=mysql
    import.torque.database.driver=com.mysql.jdbc.Driver
    import.torque.database.url=${EC2_DB_URL}/$SCHEMA_NAME
    import.admin.user=$EC2_RDS_KFS_ADMIN_USER
    import.admin.password=$EC2_RDS_KFS_ADMIN_PASSWORD
    import.admin.url=$EC2_DB_URL

EOF
) > impex-build.properties

# Fix the case of the table names (since EC2 is case sensitive)
perl -pi -e 's/dbTable="([^"]*)"/dbTable="\U\1"/g' $KFS_DATA_DIR/graphs/*.xml
perl -pi -e 's/viewdefinition="([^"]*)"/viewdefinition="\U\1"/g' $KFS_DATA_DIR/schema.xml
perl -pi -e 's/&#[^;]*;/ /gi' $KFS_DATA_DIR/schema.xml

ant -Duser.home=$WORKSPACE -buildfile kul-cfg-dbs/impex/build.xml create-schema import

EC2_RDS_INSTANCE_TYPE=${EC2_RDS_INSTANCE_TYPE:-db.m1.small}
EC2_RDS_SECURITY_GROUP=${EC2_RDS_SECURITY_GROUP:-kfs-rds-servers}
EC2_RDS_PARAMETER_GROUP=${EC2_RDS_PARAMETER_GROUP:-kfs-parameter-group}
EC2_AVAILABILITY_ZONE=${EC2_AVAILABILITY_ZONE:-us-east-1b}

INSTANCE_NAME=kfs-${INSTANCE}

echo Checking for an existing instance for this service: $INSTANCE_NAME
OLD_STATUS=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f 8 -d ,`
if [ "$OLD_STATUS" = "available" ]; then
    echo An Instance for $INSTANCE_NAME is already running:
    rds-describe-db-instances $INSTANCE_NAME
    exit 0;
fi
echo No Existing instances running with this name - proceeding with launch

rds-restore-db-instance-from-db-snapshot $INSTANCE_NAME \
--db-snapshot-identifier $SNAPSHOT_NAME \
--db-instance-class ${EC2_RDS_INSTANCE_TYPE} \
--availability-zone $EC2_AVAILABILITY_ZONE

# Wait until the instance is available
echo Starting instance $INSTANCE_NAME - this takes a few minutes
DONE="false"
while [ "$DONE" = "false" ]
do
   STATUS=`rds-describe-db-instances $INSTANCE_NAME --show-long | grep DBINSTANCE | cut -f 8 -d ,`
   if [ "$STATUS" = "available" ]; then
      DONE="true"
   else
      echo Waiting...$STATUS
      sleep 10
   fi
done
echo $INSTANCE_NAME Is Available

echo Updating Settings After Restore

rds-modify-db-instance $INSTANCE_NAME \
--apply-immediately \
--backup-retention-period 0 \
--db-parameter-group-name $EC2_RDS_PARAMETER_GROUP \
--db-security-groups $EC2_RDS_SECURITY_GROUP

INSTANCE=SET ME!!!
EC2_INSTANCE_TYPE=
DMEID=SET ME!!!
DYNDNS=true/false
ELASTIC_IP=SET ME IF NEEDED

# DNS Made Easy Information
DMEUSER=xxxxx
# This is your password
DMEPASS=xxxxx
# This is the unique number for the record that you are updating.
# This number can be obtained by clicking on the DDNS link for the
# record that you wish to update; the number for the record is listed
# on the next page.
#DMEID=

cat > ${INSTANCE}-cloud-init <<EOF
#!/bin/bash

yum -y install tomcat6
yum -y install lynx

if [[ "$DYNDNS" == "true" ]]; then
  IPADDR=\`ec2-metadata | grep public-ipv4 | awk '{ print \$2 };'\`
  RESULT=\`wget -q -O /proc/self/fd/1 http://www.dnsmadeeasy.com/servlet/updateip?username=${DMEUSER}\&password=${DMEPASS}\&id=${DMEID}\&ip=\$IPADDR\`
  echo \$RESULT
  logger -t DNS-Made-Easy -s "DNS Update Result: \$RESULT"
fi
(
cat <<-XXXXX
56c56
< Defaults    requiretty
---
> #Defaults    requiretty
XXXXX
) > /root/etc-sudoers-patch

patch /etc/sudoers /root/etc-sudoers-patch

echo "Done" > /home/ec2-user/done.txt
EOF

EC2_INSTANCE_TYPE=${EC2_INSTANCE_TYPE:-m1.large}
EC2_SECURITY_ZONE=${EC2_SECURITY_ZONE:-kfs-test-servers}
EC2_AVAILABILITY_ZONE=${EC2_AVAILABILITY_ZONE:-us-east-1b}
AMI_ID=${AMI_ID:-ami-38c33651}

mkdir -p $INSTANCE

# make sure an instance is not already running of the given type
echo Checking for an existing instance for this service: $INSTANCE
OLD_STATUS=`ec2-describe-instances --filter tag:Name=kfs-$INSTANCE | grep INSTANCE | cut -f6`
if [ "$OLD_STATUS" = "running" ]; then
    OLD_INSTANCE_ID=`ec2-describe-instances --filter tag:Name=kfs-$INSTANCE | grep INSTANCE | cut -f2`
    echo An Instance for $INSTANCE is already running: $OLD_INSTANCE_ID
    exit 0
fi

# Create the instance - capture the output to get the instance ID
ec2-run-instances $AMI_ID \
-t ${EC2_INSTANCE_TYPE} \
-g ${EC2_SECURITY_ZONE} \
-k kfs-key \
--availability-zone ${EC2_AVAILABILITY_ZONE} \
--user-data-file=${INSTANCE}-cloud-init > ${INSTANCE}/instance-info.txt
if [ $? != 0 ]; then
   echo Error starting $INSTANCE instance for image $AMI_ID
   exit 1
fi


# get the instance id
grep INSTANCE ${INSTANCE}/instance-info.txt | cut -f2 > ${INSTANCE}/instance-id.txt
INSTANCE_ID=`cat ${INSTANCE}/instance-id.txt`


# Wait until the instance has started
echo Starting instance $INSTANCE_ID
DONE="false"
while [ "$DONE" = "false" ]
do
   STATUS=`ec2-describe-instances $INSTANCE_ID | grep INSTANCE | cut -f6`
   echo $STATUS
   if [ "$STATUS" = "running" ]; then
      DONE="true"
   else
      echo Waiting...
      sleep 10
   fi
done
echo $INSTANCE_ID Is Running

ec2-create-tags $INSTANCE_ID --tag Name=kfs-${INSTANCE} --tag ServerType=KFS --tag Instance=${INSTANCE}

# Now, re-pull the instance information
ec2-describe-instances $INSTANCE_ID > ${INSTANCE}/instance-info.txt
grep INSTANCE ${INSTANCE}/instance-info.txt | cut -f4 > ${INSTANCE}/instance-host.txt
grep INSTANCE ${INSTANCE}/instance-info.txt | cut -f18 > ${INSTANCE}/instance-ip.txt

SERVER_HOST=`cat ${INSTANCE}/instance-ip.txt`

SSH_KEY_FILE=${HOME}/.ec2/kfs-key.pem
SSH_USER=${SSH_USER:-ec2-user}
SSH_PARM="-i $SSH_KEY_FILE -o BatchMode=yes -o StrictHostKeyChecking=no"
SCP_CMD="scp $SSH_PARM"
SSH_CMD="ssh $SSH_PARM ${SSH_USER}@${SERVER_HOST}"

echo Sleeping to give init scripts a chance to finish
sleep 60

echo Waiting until instance init scripts have completed
DONE="false"
while [ "$DONE" = "false" ]
do
   set +e
   STATUS=`$SSH_CMD cat done.txt`
   set -e
   echo "File Contents: $STATUS"
   if [ "$STATUS" = "Done" ]; then
      DONE="true"
   else
      echo Waiting...
      sleep 10
   fi
done
echo $INSTANCE_ID Is Running

if [[ ! -z "$ELASTIC_IP" ]]; then
    ec2-associate-address $ELASTIC_IP -i $INSTANCE_ID
fi

if [[ "$DYNDNS" == "true" ]]; then
  IPADDR=`grep INSTANCE ${INSTANCE}/instance-info.txt | cut -f 17`
  curl -v http://www.dnsmadeeasy.com/servlet/updateip?username=${DMEUSER}\&password=${DMEPASS}\&id=${DMEID}\&ip=$IPADDR
fi

ELASTIC_IP=184.73.254.131
EC2_INSTANCE_TYPE=m1.large
DYNDNS=false
INSTANCE=ptd
KFS_SCHEMA_NAME=kfs
SERVER_HOST=testdrive.kfs.kuali.org
SERVER_PORT=80
POOL_SIZE=100
STANDALONE_RICE=false

BUILD_KFS=${BUILD_KFS:-true}
COPY_BINARIES=${COPY_BINARIES:-true}
PREPARE_SERVER=${PREPARE_SERVER:-true}

KFS_SCHEMA_NAME=${KFS_SCHEMA_NAME:-kfs}
RICE_SCHEMA_NAME=${RICE_SCHEMA_NAME:-$KFS_SCHEMA_NAME}
POOL_SIZE=${POOL_SIZE:-20}
STANDALONE_RICE=${STANDALONE_RICE:-true}
SERVER_HOST=${SERVER_HOST:-${INSTANCE}.kfs.kuali.org}
SERVER_PORT=${SERVER_PORT:-8080}

SERVER_PRIVATE_IP=`ec2-describe-instances --filter tag:Name=kfs-${INSTANCE} --filter instance-state-name=running | grep INSTANCE | cut -f 18`

APPSERVER_URL=http://${SERVER_HOST}
if [[ "$SERVER_PORT" != "80" ]]; then
    APPSERVER_URL=${APPSERVER_URL}:${SERVER_PORT}
fi

if [[ "$STANDALONE_RICE" == "true" ]]; then
    RICE_URL=http://${SERVER_HOST}:8081/kr-$INSTANCE
else
    RICE_URL=$APPSERVER_URL/kfs-${INSTANCE}
fi

DATABASE_HOST=`rds-describe-db-instances kfs-$INSTANCE --show-long | grep DBINSTANCE | cut -f9 -d,`

if [ "$SSH_KEY_FILE" == "" ]; then
	SSH_KEY_FILE=${HOME}/ec2/.ec2/kfs-key.pem
fi

SSH_USER=${SSH_USER:-ec2-user}
BASEDIR=$WORKSPACE
KFS_DIR=$BASEDIR/kfs

SSH_PARM="-i $SSH_KEY_FILE -o BatchMode=yes -o StrictHostKeyChecking=no"
SCP_CMD="scp $SSH_PARM"
SSH_CMD="ssh $SSH_PARM ${SSH_USER}@${SERVER_PRIVATE_IP}"
BUILD_VERSION="`svn info kfs | grep URL | grep -o branches.*` (rev:`svn info kfs | grep Revision: | grep -o " .*"`) ${BUILD_ID}"

# build the system binaries
if [ "$BUILD_KFS" == "true" ]; then
	echo '*** Building KFS'
        echo "" > $BASEDIR/kfs-build.properties
	pushd $KFS_DIR
	ant clean-project dist dist-external \
	-Duser.home=$BASEDIR \
"-Dbuild.version=$BUILD_VERSION" \
-Dexternal.config.directory=/opt \
	-Dappserver.url=$APPSERVER_URL \
	-Dstandalone.rice=${STANDALONE_RICE} \
	-Drice.url=$RICE_URL \
	-Ddeploy.working.directory=${BASEDIR} \
	-Dbuild.environment=${INSTANCE} \
	-Duse.quartz.jdbc.jobstore=false \
-Ddatasource.pool.size=${POOL_SIZE} \
-Ddont.filter.project.spring.ide= \
-Ddo.filter.project.help= \
-Drice.thread.pool.size=${POOL_SIZE} \
	-Ddatasource.ojb.platform=MySQL \
	-Dmysql.datasource.url=jdbc:mysql://${DATABASE_HOST}:3306/${KFS_SCHEMA_NAME} \
	-Ddatasource.username=${KFS_SCHEMA_NAME} \
	-Ddatasource.password=${KFS_SCHEMA_NAME} \
	-Drice.server.datasource.url=jdbc:mysql://${DATABASE_HOST}:3306/${RICE_SCHEMA_NAME} \
	-Drice.server.datasource.username=${RICE_SCHEMA_NAME} \
	-Drice.server.datasource.password=${RICE_SCHEMA_NAME}
	popd
fi

if [ "$COPY_BINARIES" == "true" ]; then
	echo '*** Copying Compiled Binaries to Server'
	echo $SERVER_PRIVATE_IP

	pushd $KFS_DIR
	$SCP_CMD kfs-${INSTANCE}.war "${SSH_USER}@${SERVER_PRIVATE_IP}:~"
	popd
	$SCP_CMD settings.zip ${SSH_USER}@${SERVER_PRIVATE_IP}:~
	$SCP_CMD security.zip ${SSH_USER}@${SERVER_PRIVATE_IP}:~
	$SCP_CMD skel.zip ${SSH_USER}@${SERVER_PRIVATE_IP}:~
	$SSH_CMD mkdir appserver-lib
	$SCP_CMD $KFS_DIR/build/external/appserver/carol.properties ${SSH_USER}@${SERVER_PRIVATE_IP}:~/appserver-lib
	$SCP_CMD $KFS_DIR/build/external/appserver/*.jar ${SSH_USER}@${SERVER_PRIVATE_IP}:~/appserver-lib
	$SCP_CMD $KFS_DIR/build/drivers/*.jar ${SSH_USER}@${SERVER_PRIVATE_IP}:~/appserver-lib
fi

if [ "$PREPARE_SERVER" == "true" ]; then
	echo '*** Preparing Files On Server'
	# Build the script for unpacking everything on the server
	# Create /opt structure
	# Unpack files

	# NOTE: this script will be running as root
	(
	cat <<-EOF
		set -x
		mkdir -p /opt/sa_forms/java/${INSTANCE}/kfs
		mkdir -p /opt/j2ee/${INSTANCE}/kfs
		mkdir -p /opt/logs/${INSTANCE}/kfs
		mkdir -p /opt/work/${INSTANCE}/kfs

		# changing the owner so that tomcat can read/write these directories
		chown -R tomcat /opt/sa_forms
		chown -R tomcat /opt/j2ee
		chown -R tomcat /opt/logs
		chown -R tomcat /opt/work

		# Unpacking as tomcat for proper permissions
		sudo -u tomcat unzip -o skel.zip -d /opt/work/${INSTANCE}/kfs
		sudo -u tomcat unzip -o security.zip -d /opt/sa_forms/java/${INSTANCE}/kfs
		sudo -u tomcat unzip -o settings.zip -d /opt/j2ee/${INSTANCE}/kfs

		# Copy the war
		sudo -u tomcat cp kfs-${INSTANCE}.war /usr/share/tomcat6/webapps/

		# Copy the server lib dirs
		cp appserver-lib/* /usr/share/tomcat6/lib/

		# Prepare the Tomcat Web App
		# First - global tomcat server settings
		echo 'JAVA_OPTS="\$JAVA_OPTS -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=128 -XX:MaxTenuringThreshold=0 -XX:+UseTLAB"' >> /etc/tomcat6/tomcat6.conf
		echo 'JAVA_OPTS="\$JAVA_OPTS -XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled"' >> /etc/tomcat6/tomcat6.conf
		echo 'JAVA_OPTS="\$JAVA_OPTS -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Djava.awt.headless=true"' >> /etc/tomcat6/tomcat6.conf
		echo 'JAVA_OPTS="\$JAVA_OPTS -Dcom.sun.jndi.ldap.read.timeout=60000 -Dcom.sun.jndi.ldap.connect.pool.timeout=30000 -Dcom.sun.jndi.ldap.connect.timeout=10000"' >> /etc/tomcat6/tomcat6.conf
		echo 'JAVA_OPTS="\$JAVA_OPTS -Dnetworkaddress.cache.ttl=60 -Doracle.net.CONNECT_TIMEOUT=10000 -Djava.util.prefs.syncInterval=2000000"' >> /etc/tomcat6/tomcat6.conf
		echo -n 'JAVA_OPTS="\$JAVA_OPTS ' >> /etc/tomcat6/tomcat6.conf
		echo "-Dhttp.url=${SERVER_HOST}:${SERVER_PORT} -Dhost.ip=${SERVER_PRIVATE_IP}\"" >> /etc/tomcat6/tomcat6.conf

		# Next - the KFS instance specific settings
		echo 'JAVA_OPTS="\$JAVA_OPTS -Xmx4g -Xms2g -XX:MaxPermSize=1g -XX:PermSize=256m  -XX:MaxNewSize=256m -XX:NewSize=256m"' >> /etc/sysconfig/tomcat6
		#echo "CONNECTOR_PORT=\"${SERVER_PORT}\"" >> /etc/sysconfig/tomcat6

		# patch the startup script because it doesn't work
		patch -b /usr/sbin/tomcat6 usr-sbin-tomcat6-patch

                # fix the connector port because the above is ignored
                /sbin/iptables -t nat -I PREROUTING -p tcp --dport ${SERVER_PORT} -j REDIRECT --to-port 8080
                /sbin/iptables-save
                chkconfig --level 35 iptables on
                service iptables start

                #perl -pi -e "s/8080/${SERVER_PORT}/gi" /etc/tomcat6/server.xml

		# Start the tomcat server
		service tomcat6 start
	EOF
	) > kfs-init.sh
	# Copy the completed script to the server
	$SCP_CMD kfs-init.sh ${SSH_USER}@${SERVER_PRIVATE_IP}:~
	# Copy the patch file
	$SCP_CMD usr-sbin-tomcat6-patch ${SSH_USER}@${SERVER_PRIVATE_IP}:~

	# make the script executable
	$SSH_CMD chmod a+rx kfs-init.sh
	# Make the directory readable so tomcat can see it
	$SSH_CMD chmod o+rx .
	# Run the initialization script
	$SSH_CMD -t sudo ./kfs-init.sh
fi

echo Server URL: ${APPSERVER_URL}/kfs-${INSTANCE}

ssh -i .ec2/kfs-key.pem ec2-user@testdrive.kfs.kuali.org