<?xml version="1.0" encoding="ISO-8859-1"?>

<!-- Copyright 2006 The Apache Software Foundation 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@incubator.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>
