<?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>

	<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">
				<i>Tested with IBM DB2 Express-C 9.7.x</i>
				<ul>
					<li>
						Get the IBM Data Server Driver for JDBC and SQLJ from IBM website:
						<a
							href="https://www14.software.ibm.com/webapp/iwm/web/preLogin.do?source=swg-idsdjs">https://www14.software.ibm.com/webapp/iwm/web/preLogin.do?source=swg-idsdjs
						</a>
					</li>
					<li>Copy JDBC driver db2jcc4.jar to
						webapps/openmeetings/WEB-INF/lib/
					</li>
					<li>
						Create database for OpenMeetings using a pagesize bigger or equal
						8K, sample query:
						<br />
						<div class="xmlcode">
							CREATE DATABASE openmeet AUTOMATIC STORAGE YES ON 'C:' DBPATH ON 'C:'
							USING CODESET UTF-8 TERRITORY DE COLLATE USING System PAGESIZE 16
							K
						</div>
					</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/db2_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="DB2 Sample Configuration">
				<p>
					There is a sample configuration for IBM DB2 that ships with
					every
					release in:
					<br />
					/webapps/openmeetings/WEB-INF/classes/META-INF/db2_persistence.xml
				</p>
			</subsection>


		</section>

	</body>

</document>
