<?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="http://www.apache.org/dist/bigtop/bigtop-1.0.0/">Bigtop-1.0.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 are 2 Jenkins servers currently running for the project:
			</p>
			<ul>
				<li>
					<a href="http://ci.bigtop.apache.org:8080/">http://ci.bigtop.apache.org:8080/</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>
