<?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>PostgreSQL Configuration</title>
		<author email="sebawagner@apache.org">
			Apache OpenMeetings Documentation Team
		</author>
	</properties>

	<body>
		<section name="PostgreSQL Configuration">

			<subsection name="Before you start">
				<ul>
					<li>Make sure that you have set utf8 as default/server-character-set 
					</li>
					<li>
						make sure PostgreSQL is listening on TCP/IP connections!
						<br />
						To verify if PostgreSQL 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 again and delete
						the file $red5/webapps/openmeetings/conf/install.xml and then run
						the web based installer again
					</li>
					<li><span style="font-size: larger; color: blue;">IMPORTANT</span> According to
						<a href="http://markmail.org/message/opymlab2e6wygb7p">this</a> thread you need to ensure:<br/>
						<tt>standard_conforming_strings</tt> is set to <tt><b>on</b></tt> and <br/>
						<tt>escape_string_warning</tt> is set to <tt><b>off</b></tt>
					</li>
				</ul>
			</subsection>

			<subsection name="Steps todo">
				<ul>
					<li>
						Rename:
						<br />
						$red5/webapps/openmeetings/WEB-INF/classes/META-INF/postgresql_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 DB_HOST USER_NAME USER_PASS
						with your values
					</li>
					<li>
						Run red5-service and goto the web-based installer:
						http://localhost:5080/openmeetings/install
					</li>
				</ul>
			</subsection>

			<subsection name="PostgreSQL Sample Configuration">
				<p>
					There is a sample configuration for PostgreSQL that ships with
					every
					release in:
					<br />
					/webapps/openmeetings/WEB-INF/classes/META-INF/postgresql_persistence.xml
				</p>
			</subsection>


		</section>

	</body>

</document>
