<?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>MySQL Configuration</title>
		<author email="sebawagner@apache.org">
			Apache OpenMeetings Documentation Team
		</author>
	</properties>

	<body>
		<section name="MySQL Configuration">

			<subsection name="Before you start">
				<ul>
					<li>Make sure that you have set utf8 as
						default/server-character-set in your MySQL configuration (my.cnf)
						before you start the installation process of OpenMeetings!
					</li>
					<li>
						make sure MySQL is listening on TCP/IP connections!
						<br />
						To verify if MySQL connection is working: OpenMeetings will
						automatically create all tables in the database and all tables
						should have utf8 as encoding/collation!
					</li>
					<li>If you encounter issues, you can drop the db and then run
						the web based installer again
					</li>
				</ul>
			</subsection>

			<subsection name="Steps todo">
				<ul>
					<li>
						You need to download the JConnector from mysql
						<a href="http://www.mysql.com/downloads/connector/j/" target="_BLANK"
							rel="nofollow">http://www.mysql.com/downloads/connector/j/</a>
						and place it into:
						<tt>$red5/webapps/openmeetings/WEB-INF/lib/</tt>
					</li>
					<li>
						Run red5-service and goto the web-based installer:
						http://localhost:5080/openmeetings/install
					</li>
				</ul>
			</subsection>

			<subsection name="MySQL Sample Configuration">
				<p>
					There is a sample configuration for MySQL that ships with
					every
					release in:
					<br />
					/webapps/openmeetings/WEB-INF/classes/META-INF/mysql_persistence.xml
				</p>
			</subsection>


		</section>

	</body>

</document>
