<?xml version="1.0" encoding="UTF-8"?>
<!--
   Licensed 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.
 -->
<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="website.xsd">

	<properties>
		<title>IBM DB2 Configuration</title>
		<author email="sebawagner@apache.org">
			Apache OpenMeetings Documentation Team
		</author>
	</properties>

	<body>
		<section name="IBM DB2 Configuration">

			<subsection name="Before you start">
				<ul>
					<li>Download the latest JDBC Driver from Oracle for your database
						version. Place those JARs into
						$Red5/webapps/openmeetings/WEB-INF/lib
					</li>
					<li>If you encounter issues, you can drop the db again and delete
						the file $red5/webapps/openmeetings/conf/install.xml and then run
						the web based installer again
					</li>
				</ul>
			</subsection>

			<subsection name="Steps todo">
				<ul>
					<li>
						Rename:
						<br />
						$red5/webapps/openmeetings/WEB-INF/classes/META-INF/oracle_persistence.xml
						<br />
						to
						<br />
						$red5/webapps/openmeetings/WEB-INF/classes/META-INF/persistence.xml
					</li>
					<li>
						Prepare Database Settings - go to
						openmeetings_version_no_xx/webapps/openmeetings/WEB-INF/classes/META-INF/persistence.xml
						<br />
						Alter config values in persistence.xml connectionURL, username and
						password with your values
					</li>
					<li>
						Run red5-service and goto the web-based installer:
						http://localhost:5080/openmeetings/install
					</li>
				</ul>
			</subsection>

			<subsection name="Oracle Sample Configuration">
				<p>
					There is a sample configuration for Oracle that ships with
					every release in:
					<br />
					/webapps/openmeetings/WEB-INF/classes/META-INF/oracle_persistence.xml
				</p>
			</subsection>


		</section>

	</body>

</document>
