<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file 
	distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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="http://maven.apache.org/XDOC/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 http://maven.apache.org/xsd/xdoc-2.0.xsd">
	<properties>
		<title>Apache Bigtop</title>
	</properties>
	<body>

		<section name="Apache Bigtop">
			<p>
			<b>
				Bigtop is an Apache Foundation project for Infrastructure Engineers and Data Scientists looking for comprehensive packaging, testing, and configuration of the leading open source big data components.
			</b>
				Bigtop supports a wide range of components/projects, including, but not limited to, Hadoop, HBase and Spark.

			</p>
			<br />
			<table>
				<tr>
					<th>Packaging</th>
					<th>Smoke testing</th>
					<th>Virtualization</th>
				</tr>
				<tr>
					<td>
						Bigtop packages Hadoop RPMs and DEBs, so that you can manage and maintain your Hadoop cluster.
					</td>
					<td>
						Bigtop provides an integrated smoke testing framework, alongside a suite of over 50 test files.
					</td>
					<td>
						Bigtop provides vagrant recipes, raw images, and (work-in-progress) docker recipes for deploying 
						Hadoop from zero.
					</td>
				</tr>
			</table>
			<br />
			<p>
					Bigtop support many Operating Systems, including Debian, Ubuntu, CentOS, Fedora, openSUSE and many others.

			</p>
			<p>
					Bigtop includes tools and a framework for testing at various levels (packaging, platform, runtime, etc.) for both initial deployments as well as upgrade scenarios for the entire data platform, not just the individual components.
			</p>
			<br />
			<br />

			<subsection name="Download latest release of Bigtop"></subsection>
			<p><a href="download.html#releases">Bigtop-1.3.0</a> </p>

			<subsection name="All required tools will be installed by ./gradlew toolchain"></subsection>
			<p>However place supply a suitable JRE (for instance openjdk7) first</p>


			<subsection name="Continuous Integration"></subsection>
			<p>
				Apache Bigtop uses Jenkins for continuous integration testing (you can learn more about Jenkins
				<a href="http://jenkins-ci.org/">here</a>
				).
				There is a Jenkins server currently running for the project:
			</p>
			<ul>
				<li>
					<a href="https://ci.bigtop.apache.org/">https://ci.bigtop.apache.org/</a>
				</li>
			</ul>
			<p>
				The Apache Jenkins server runs the "Bigtop-trunk" job whenever code is committed to the trunk branch, which in turn
				runs several test jobs.
			</p>
			<p>
				In each branch there is a job to build each component, a job to run package tests and a job to build package
				repositories.
			</p>
		</section>
	</body>
</document>
