
<!DOCTYPE html>
<!--
 Generated by Apache Maven Doxia at 2017-02-08
 Rendered using Reflow Maven Skin 1.1.1 (http://andriusvelykis.github.io/reflow-maven-skin)
-->
<html  xml:lang="en" lang="en">

	<head>
		<meta charset="UTF-8" />
		<title>Apache OpenMeetings Project - 
		Installation</title>
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<meta name="description" content="" />
		<meta name="author" content="Apache OpenMeetings Team" />
		<meta http-equiv="content-language" content="en" />
 
		<link href=".//css/bootstrap.min.css" rel="stylesheet" />
		<link href=".//css/bootstrap-responsive.min.css" rel="stylesheet" />
		<link href=".//css/docs.css" rel="stylesheet" />
		<link href=".//css/reflow-skin.css" rel="stylesheet" />


		<link href=".//css/lightbox.css" rel="stylesheet" />

		<link href=".//css/site.css" rel="stylesheet" />
		<link href=".//css/print.css" rel="stylesheet" media="print" />

		<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
		<!--[if lt IE 9]>
			<script src=".//js/html5.js"></script>
		<![endif]-->


		
	</head>

	<body class="page-installation project-openmeetings-server" data-spy="scroll" data-offset="60" data-target="#toc-scroll-target">

		<div class="navbar navbar-fixed-top">
			<div class="navbar-inner">
				<div class="container">
					<a class="btn btn-navbar" data-toggle="collapse" data-target="#top-nav-collapse">
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
					</a>
					<div class="brand"><span class="color-highlight">Apache</span> OpenMeetings</div>
					<div class="nav-collapse collapse" id="top-nav-collapse">
						<ul class="nav pull-right">
							<li ><a href="demo.html" title="Demo">Demo</a></li>
							<li ><a href="downloads.html" title="Download">Download</a></li>
							<li ><a href="https://cwiki.apache.org/confluence/display/OPENMEETINGS" title="Wiki" class="externalLink">Wiki</a></li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">General <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="index.html" title="Home">Home</a></li>
									<li ><a href="license.html" title="License">License</a></li>
									<li ><a href="http://www.apache.org/" title="ASF" class="externalLink">ASF</a></li>
									<li ><a href="CallForLogo.html" title="Call For Logo">Call For Logo</a></li>
									<li ><a href="NewsArchive.html" title="News archive">News archive</a></li>
									<li ><a href="security.html" title="Security">Security</a></li>
									<li ><a href="commercial-support.html" title="Commercial Support">Commercial Support</a></li>
								</ul>
							</li>
							<li class="dropdown active">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Installation <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li class="active"><a href="" title="Installation">Installation</a></li>
									<li ><a href="Upgrade.html" title="Upgrade">Upgrade</a></li>
									<li ><a href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Tutorials+for+installing+OpenMeetings+and+Tools" title="Tutorials" class="externalLink">Tutorials</a></li>
									<li ><a href="CommandLineAdmin.html" title="Command Line Admin">Command Line Admin</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Community <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="get-involved.html" title="Get Involved">Get Involved</a></li>
									<li ><a href="team-list.html" title="Committers">Committers</a></li>
									<li ><a href="mail-lists.html" title="Mailing Lists">Mailing Lists</a></li>
									<li ><a href="http://cwiki.apache.org/confluence/display/OPENMEETINGS/" title="Wiki" class="externalLink">Wiki</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Development <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="source-repository.html" title="Source Code">Source Code</a></li>
									<li ><a href="issue-tracking.html" title="Bugs / Issues">Bugs / Issues</a></li>
									<li ><a href="dependencies.html" title="Dependencies">Dependencies</a></li>
									<li ><a href="integration.html" title="Continuous Integration">Continuous Integration</a></li>
									<li ><a href="BuildInstructions_3.0.x.html" title="Build Instructions 3.0.x">Build Instructions 3.0.x</a></li>
									<li ><a href="BuildInstructions.html" title="Build Instructions">Build Instructions</a></li>
									<li ><a href="JUnitTesting.html" title="JUnit Testing">JUnit Testing</a></li>
									<li ><a href="ManualTesting.html" title="Manual Testing">Manual Testing</a></li>
									<li ><a href="ReleaseGuide.html" title="Release Guide">Release Guide</a></li>
									<li ><a href="WebsiteGuide.html" title="Website Guide">Website Guide</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Configuration <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li class="dropdown-submenu ">
										<a href="installation.html#integration" title="Integration">Integration</a>
										<ul class="dropdown-menu">
											<li ><a href="openmeetings-webservice/apidocs/index.html" title="SOAP/REST API" target="_blank">SOAP/REST API</a></li>
											<li ><a href="RestAPISample.html" title="REST API Sample">REST API Sample</a></li>
											<li ><a href="LdapAndADS.html" title="Ldap and ADS">Ldap and ADS</a></li>
											<li ><a href="oauth2.html" title="OAuth2">OAuth2</a></li>
											<li ><a href="voip-sip-integration.html" title="VoIP and SIP">VoIP and SIP</a></li>
											<li ><a href="errorvalues.html" title="Errors table">Errors table</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#plugins" title="Plugins">Plugins</a>
										<ul class="dropdown-menu">
											<li ><a href="MoodlePlugin.html" title="Moodle Plugin">Moodle Plugin</a></li>
											<li ><a href="SakaiPlugin.html" title="Sakai Plugin">Sakai Plugin</a></li>
											<li ><a href="JiraPlugin.html" title="Jira Plugin">Jira Plugin</a></li>
											<li ><a href="JoomlaPlugin.html" title="Joomla Plugin">Joomla Plugin</a></li>
											<li ><a href="DrupalPlugin.html" title="Drupal Plugin">Drupal Plugin</a></li>
											<li ><a href="BitrixPlugin.html" title="Bitrix Plugin">Bitrix Plugin</a></li>
											<li ><a href="ConfluencePlugin.html" title="Confluence Plugin">Confluence Plugin</a></li>
											<li ><a href="SugarCRMPlugin.html" title="SugarCRM Plugin">SugarCRM Plugin</a></li>
											<li ><a href="RedminePlugin.html" title="Redmine Plugin">Redmine Plugin</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#db" title="DB Sample Configurations">DB Sample Configurations</a>
										<ul class="dropdown-menu">
											<li ><a href="ApacheDerbyConfig.html" title="Apache Derby">Apache Derby</a></li>
											<li ><a href="IBMDB2Config.html" title="IBM DB2">IBM DB2</a></li>
											<li ><a href="OracleConfig.html" title="Oracle">Oracle</a></li>
											<li ><a href="MySQLConfig.html" title="MySQL">MySQL</a></li>
											<li ><a href="PostgresConfig.html" title="Postgres">Postgres</a></li>
											<li ><a href="MSSQLConfig.html" title="MSSQL">MSSQL</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#localization" title="Localization and languages">Localization and languages</a>
										<ul class="dropdown-menu">
											<li ><a href="Internationalisation.html" title="Internationalisation">Internationalisation</a></li>
											<li ><a href="LanguageEditor.html" title="LanguageEditor">LanguageEditor</a></li>
											<li ><a href="TimeZoneHandling.html" title="TimeZoneHandling">TimeZoneHandling</a></li>
											<li ><a href="EditTemplates.html" title="EditTemplates">EditTemplates</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#port" title="NAT Port Settings">NAT Port Settings</a>
										<ul class="dropdown-menu">
											<li ><a href="PortSettings.html" title="Port settings">Port settings</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#performance" title="Performance">Performance</a>
										<ul class="dropdown-menu">
											<li ><a href="JVMPerformanceTuning.html" title="JVM performance tuning">JVM performance tuning</a></li>
											<li ><a href="NetworkCalculator.html" title="Network bandwidth calculator">Network bandwidth calculator</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#interface" title="User Interface">User Interface</a>
										<ul class="dropdown-menu">
											<li ><a href="themes-and-branding.html" title="Themes">Themes</a></li>
											<li ><a href="Dashboard.html" title="Dashboard">Dashboard</a></li>
											<li ><a href="WebcamResolutions.html" title="Webcam resolutions">Webcam resolutions</a></li>
											<li ><a href="ConferenceRoomLayoutOptions.html" title="Room layout options">Room layout options</a></li>
											<li ><a href="HotKeys.html" title="Hot Keys">Hot Keys</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#customize" title="Customization">Customization</a>
										<ul class="dropdown-menu">
											<li ><a href="WebappNamePath.html" title="Webapp name/path">Webapp name/path</a></li>
											<li ><a href="Navigation.html" title="Navigation">Navigation</a></li>
											<li ><a href="CalendarAndTimezone.html" title="Calendar and timezone">Calendar and timezone</a></li>
											<li ><a href="CustomRoomTypeHowTo.html" title="Custom room type">Custom room type</a></li>
											<li ><a href="CustomCryptMechanism.html" title="Custom crypt mechanism">Custom crypt mechanism</a></li>
											<li ><a href="GeneralConfiguration.html" title="General Configuration">General Configuration</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#security" title="Security">Security</a>
										<ul class="dropdown-menu">
											<li ><a href="RestrictedAccess.html" title="Restricted Access">Restricted Access</a></li>
											<li ><a href="RTMPSAndHTTPS.html" title="RTMPS and HTTPS">RTMPS and HTTPS</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#convert" title="Converters">Converters</a>
										<ul class="dropdown-menu">
											<li ><a href="OpenOfficeConverter.html" title="OpenOffice Converter">OpenOffice Converter</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#cluster" title="Clustering">Clustering</a>
										<ul class="dropdown-menu">
											<li ><a href="Clustering.html" title="Clustering">Clustering</a></li>
										</ul>
									</li>
									<li class="dropdown-submenu ">
										<a href="installation.html#misc" title="Misc">Misc</a>
										<ul class="dropdown-menu">
											<li ><a href="GetVersionInfo.html" title="Get version info">Get version info</a></li>
										</ul>
									</li>
								</ul>
							</li>
						</ul>
					</div><!--/.nav-collapse -->
				</div>
			</div>
		</div>

	<div class="container">

	<!-- Masthead
	================================================== -->

	<header>
	<div class="jumbotron subhead">
		<div class="row" id="banner">
			<div class="span12">
				<div class="pull-left">
					<a href="index.html" id="bannerLeft"><img src="images/logo.png" alt='"'Apache OpenMeetings'"' /></a>
				</div>
				<div class="pull-right">
					<a href="http://apache.org" id="bannerRight"><img src="http://apache.org/img/asf_logo.png" alt='"'Apache'"' /></a>
				</div>
			</div>
		</div>
	</div>
		<div>
			<ul class="breadcrumb">
				<li class="publishDate version-date">Last Published: 2017-02-08</li>
			</ul>
		</div>
	</header>

	<div class="main-body">
	<div class="row">
		<div class="span8">
			<div class="body-content">
<!-- 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. --> 
<div class="section"> 
 <div class="page-header">
  <h2 id="OpenMeetings_Installation">OpenMeetings Installation</h2>
 </div> 
 <p> To update from past versions or migrate see <a href="Upgrade.html">Upgrade</a>.<br /> If you are looking for commercial help have a look at <a href="commercial-support.html" target="_blank" rel="nofollow">commercial support</a>. </p> 
 <div> 
  <a href="downloads.html" rel="nofollow"> <img src="images/installation_instructions.png" alt="Installation in 3 simple steps" /> </a> 
  <p> <i>Note: Openmeetings requires JRE 7/8, JRE 6 is NOT compatible!</i><br /> <i> Since Version 2.0 you can also install OpenMeetings from command line. Just cd to the unpacked archive and type ./admin.sh or admin.bat, please see <a href="CommandLineAdmin.html" target="_blank" rel="nofollow">Command Line Admin</a> for more options </i> </p> 
 </div> 
 <ol style="list-style-type: decimal"> 
  <li> <b>Recommendation for production environment</b> 
   <div style="margin-top: 10px; margin-bottom:10px">
     By default OpenMeetings uses the integrated Apache Derby database. For production environment you should consider using 
    <a href="MySQLConfig.html">MySQL</a> , 
    <a href="PostgresConfig.html">Postgres</a> , or for example 
    <a href="IBMDB2Config.html">IBM DB2</a> , or 
    <a href="OracleConfig.html">Oracle</a> , or 
    <a href="MSSQLConfig.html">MSSQL</a> 
   </div> </li> 
  <li> <b>Enabling Image Upload and import to whiteboard</b> 
   <div style="margin-top: 10px; margin-bottom:10px">
     Install 
    <b>ImageMagick</b> on the server, you can get more information on 
    <a class="externalLink" href="http://www.imagemagick.org" target="_blank" rel="nofollow">http://www.imagemagick.org </a> regarding installation. The instructions for installation can be found there 
    <a class="externalLink" href="http://www.imagemagick.org/script/binary-releases.php" target="_blank" rel="nofollow">http://www.imagemagick.org/script/binary-releases.php </a> , however on most Linux systems you can get it via your favorite package managers (apt-get it) 
   </div> </li> 
  <li> <b>Enabling import of PDFs into whiteboard</b> 
   <div style="margin-top: 10px; margin-bottom:10px"> 
    <ul> 
     <li> Install <b>GhostScript</b> on the server, you can get more information on <a class="externalLink" href="http://www.ghostscript.com/download/gsdnld.html" target="_blank" rel="nofollow"> http://www.ghostscript.com/download/gsdnld.html </a> regarding installation. The instructions for installation can be found there, however on most Linux systems you can get it via your favorite package managers (apt-get it). </li> 
     <li> Install <b>SWFTools</b> on the server, you can get more information on <a class="externalLink" href="http://www.swftools.org/" target="_blank" rel="nofollow">http://www.swftools.org/ </a> regarding installation. Some of the Linux distributions already have it in there package manager (see <a class="externalLink" href="http://packages.debian.org/unstable/utils/swftools" target="_blank" rel="nofollow">http://packages.debian.org/unstable/utils/swftools </a> ), the recommended version of SWFTools is 0.9 as prior version have a bug that does lead to wrong object dimensions at whiteboard </li> 
    </ul> 
   </div> </li> 
  <li> <b>Enabling import of .doc, .docx, .ppt, .pptx, ... all Office Documents into whitebaord </b> 
   <div style="margin-top: 10px; margin-bottom:10px"> 
    <ul> 
     <li>OpenOffice or Libre Office Installed</li> 
    </ul> Since Version 2.x of OpenMeetings it is no more required to start OpenOffice (or Libreoffice) service, see 
    <a href="OpenOfficeConverter.html">OpenOfficeConverter</a> for details 
   </div> </li> 
  <li> <b>Enabling Recording and import of .avi, .flv, .mov and .mp4 into whiteboard </b> 
   <div style="margin-top: 10px; margin-bottom:10px"> 
    <ul> 
     <li> Install <b>FFMpeg (with -enabled libmp3lame and libx264 options)</b> . You should get FFMPEG in an up to date copy! OpenMeetings is tested with FFMPEG Version 10.3 and latest build from GIT For Windows you can download a Build for example from <a class="externalLink" href="http://ffmpeg.zeranoe.com/builds/" target="_blank" rel="nofollow">http://ffmpeg.zeranoe.com/builds/ </a> Linux or OSx Users should be able to use one of the various Installation Instructions on the Web. You need to enable libmp3lame and libx264! </li> 
     <li> Install <b>SoX</b> <a class="externalLink" href="http://sox.sourceforge.net/" target="_blank" rel="nofollow">http://sox.sourceforge.net/ </a> . You should install SoX in a up to date copy! SoX 12.xx will NOT work! </li> 
    </ul> 
   </div> </li> 
 </ol> 
</div> 
<div class="section"> 
 <h2 id="Ports_NAT_Settings_Customize">Ports, NAT Settings, Customize</h2> 
 <p> See <a href="PortSettings.html">PortSettings</a> </p> 
</div> 
<div class="section"> 
 <h2 id="Hardware_Requirements">Hardware Requirements</h2> 
 <ul> 
  <li> Minimalistic requirement (without Document Converters, Recorder and Upload feature) 1GHz CPU 1 GB RAM ( <i>server-side</i> ) </li> 
  <li> Recommended requirement 2x/4x 2GHz ++ CPU (32 or 64Bit) 4GB RAM. If you have a 64Bit Operating System check if there is a OpenOffice 64Bit Version <a class="externalLink" href="http://download.openoffice.org/other.html#de" rel="nofollow">available for your OS </a> ( <i>server-side</i> ) </li> 
  <li> Headset/Microphone recommendation: Logitech ClearChat PC Wireless, for example from <a class="externalLink" href="http://www.amazon.de/Logitech-ClearChat-kabelloser-Kopfh%C3%B6rer-Transmitter/dp/B00166WSN4" rel="nofollow">Amazon</a> or <a class="externalLink" href="http://shop.ebay.com/i.html?_nkw=Logitech+ClearChat.+Wireless&amp;_sacat=0&amp;_trksid=p3286.m270.l1313&amp;LH_BIN=1&amp;LH_IncludeSIF=1&amp;_odkw=Logitech+ClearChat+PC&amp;_osacat=0" rel="nofollow">EBay Auctions</a> ( <i>cient-side</i> ). <a href="RecommendedHardwareList.html">See all recommendations</a> for cameras, headsets and speakerphones. </li> 
 </ul> 
</div> 
<div class="section"> 
 <h2 id="Debian_Links_Changelog_VoIP">Debian, Links, Changelog, VoIP</h2> 
 <ul> 
  <li>for VoIP and SIP Integration see also <a href="voip-sip-integration.html">VoIPAndSIP</a></li> 
  <li><a class="externalLink" href="http://meetingslive.sourceforge.net/" rel="nofollow">http://meetingslive.sourceforge.net/</a></li> 
  <li> <a class="externalLink" href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Tutorials+for+installing+OpenMeetings+and+Tools">Installation of OM 2.0 for Windows XP, 7, 2003, 2008</a> </li> 
  <li> <a class="externalLink" href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Tutorials+for+installing+OpenMeetings+and+Tools"> OpenMeetings Installation tutorials by Alvaro Bustos for: Ubuntu, Debian, Mint, MacOS X, CentOS, Fedora, PCLinuxOS, openSUSE and Arch Linux.</a> </li> 
  <li> <a class="externalLink" href="https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27837303" rel="nofollow">Tutoriales en espa&ntilde;ol relacionados con OpenMeetings</a> </li> 
  <li> <a class="externalLink" href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Tutorials+for+installing+OpenMeetings+and+Tools" rel="nofollow">Automatic script installation for Ubuntu/Debian (beta)</a> </li> 
  <li> French version of Installation Instructions: <a class="externalLink" href="http://flash.54n.free.fr/?/Root/Debian/OpenMeetings-Installation" rel="nofollow">http://flash.54n.free.fr/?/Root/Debian/OpenMeetings-Installation </a> </li> 
 </ul> 
</div> 
<div class="section"> 
 <h2 id="Tips_and_Tricks">Tips and Tricks</h2> 
 <ul> 
  <li> Use the Debug-Application: open <tt>$RED5_HOME/webapps/openmeetings/WEB-INF/web.xml</tt> change 
   <div class="source"> 
    <pre>
&lt;init-param&gt;
	&lt;param-name&gt;configuration&lt;/param-name&gt;
	&lt;param-value&gt;DEPLOYMENT&lt;/param-value&gt;
&lt;/init-param&gt;
					</pre> 
   </div> to be 
   <div class="source"> 
    <pre>
&lt;init-param&gt;
	&lt;param-name&gt;configuration&lt;/param-name&gt;
	&lt;param-value&gt;DEVELOPMENT&lt;/param-value&gt;
&lt;/init-param&gt;
					</pre> 
   </div> then access your OM installation </li> 
  <li>If you have Problems with conversion-jobs check your openmeetings log output (available at <tt>$RED5_HOME/log/openmeetings.log</tt>). There will be error Messages which help you. You must install OpenOffice, ImageMagick, GhostScript and SWFTools to run all conversion-Jobs correctly. </li> 
  <li> you can query a Mysql Database to get the schema_collection by using this query: 
   <div class="source"> 
    <pre>SELECT Table_name, TABLE_COLLATION FROM information_schema.tables WHERE table_schema = 'openmeetings' ORDER BY table_name DESC </pre> 
   </div> </li> 
 </ul> 
</div>
			</div>
		</div>
		<div class="span4">
			<div id="toc-sidebar">
				<div class="well">
					<ul class="nav nav-list">
						<li class="nav-header">Table of Contents</li>
		<li><a href="#OpenMeetings_Installation" title="OpenMeetings Installation">OpenMeetings Installation</a>
		<li><a href="#Ports_NAT_Settings_Customize" title="Ports, NAT Settings, Customize">Ports, NAT Settings, Customize</a>
		<li><a href="#Hardware_Requirements" title="Hardware Requirements">Hardware Requirements</a>
		<li><a href="#Debian_Links_Changelog_VoIP" title="Debian, Links, Changelog, VoIP">Debian, Links, Changelog, VoIP</a>
		<li><a href="#Tips_and_Tricks" title="Tips and Tricks">Tips and Tricks</a>
					</ul>
				</div>
			</div>
		</div>
	</div>
	</div>

	</div><!-- /container -->

	<!-- Footer
	================================================== -->
	<footer class="well">
		<div class="container">
			<div class="row">
				<div class="span3 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">General</li>
						<li >
							<a href="index.html" title="Home">Home</a>
						</li>
						<li >
							<a href="license.html" title="License">License</a>
						</li>
						<li >
							<a href="http://www.apache.org/" title="ASF" class="externalLink">ASF</a>
						</li>
						<li >
							<a href="CallForLogo.html" title="Call For Logo">Call For Logo</a>
						</li>
						<li >
							<a href="NewsArchive.html" title="News archive">News archive</a>
						</li>
						<li >
							<a href="security.html" title="Security">Security</a>
						</li>
						<li >
							<a href="commercial-support.html" title="Commercial Support">Commercial Support</a>
						</li>
					</ul>
				</div>
				<div class="span3 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Installation</li>
						<li class="active">
							<a href="#" title="Installation">Installation</a>
						</li>
						<li >
							<a href="Upgrade.html" title="Upgrade">Upgrade</a>
						</li>
						<li >
							<a href="https://cwiki.apache.org/confluence/display/OPENMEETINGS/Tutorials+for+installing+OpenMeetings+and+Tools" title="Tutorials" class="externalLink">Tutorials</a>
						</li>
						<li >
							<a href="CommandLineAdmin.html" title="Command Line Admin">Command Line Admin</a>
						</li>
					</ul>
				</div>
				<div class="span3 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Community</li>
						<li >
							<a href="get-involved.html" title="Get Involved">Get Involved</a>
						</li>
						<li >
							<a href="team-list.html" title="Committers">Committers</a>
						</li>
						<li >
							<a href="mail-lists.html" title="Mailing Lists">Mailing Lists</a>
						</li>
						<li >
							<a href="http://cwiki.apache.org/confluence/display/OPENMEETINGS/" title="Wiki" class="externalLink">Wiki</a>
						</li>
					</ul>
				</div>
				<div class="span3 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Development</li>
						<li >
							<a href="source-repository.html" title="Source Code">Source Code</a>
						</li>
						<li >
							<a href="issue-tracking.html" title="Bugs / Issues">Bugs / Issues</a>
						</li>
						<li >
							<a href="dependencies.html" title="Dependencies">Dependencies</a>
						</li>
						<li >
							<a href="integration.html" title="Continuous Integration">Continuous Integration</a>
						</li>
						<li >
							<a href="BuildInstructions_3.0.x.html" title="Build Instructions 3.0.x">Build Instructions 3.0.x</a>
						</li>
						<li >
							<a href="BuildInstructions.html" title="Build Instructions">Build Instructions</a>
						</li>
						<li >
							<a href="JUnitTesting.html" title="JUnit Testing">JUnit Testing</a>
						</li>
						<li >
							<a href="ManualTesting.html" title="Manual Testing">Manual Testing</a>
						</li>
						<li >
							<a href="ReleaseGuide.html" title="Release Guide">Release Guide</a>
						</li>
						<li >
							<a href="WebsiteGuide.html" title="Website Guide">Website Guide</a>
						</li>
					</ul>
				</div>
			</div>
		</div>
	</footer>

	<div class="container subfooter">
		<div class="row">
			<div class="span12">
				<p class="pull-right"><a href="#">Back to top</a></p>
				<p class="copyright">Copyright &copy;2012-2017 <a href="http://apache.org">Apache Software Foundation</a>. All Rights Reserved.</p>
			</div>
		</div>
	</div>

	<!-- Le javascript
	================================================== -->
	<!-- Placed at the end of the document so the pages load faster -->
	<script src=".//js/jquery.min.js"></script>

	<script src=".//js/bootstrap.min.js"></script>
	<script src=".//js/lightbox.min.js"></script>
	<script src=".//js/reflow-scroll.js"></script>
	
<script src=".//js/jquery-ui.min.js" type="text/javascript"></script>
<script src=".//js/netcalc.js" type="text/javascript"></script>
	<script src=".//js/reflow-skin.js"></script>

	</body>
</html>
