<!doctype html>
<!--
    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

         https://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.
-->
<html lang="en" prefix="og: https://ogp.me/ns#">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
<title>Infrastructure</title>
    <!-- Below Meta Tags Generated via https://www.opengraph.xyz -->
    <!-- If you don't care about social media then remove this section -->
    <!-- Values are set in pelicanconf.py -->
    <!-- HTML Meta Tags -->
    <meta name="description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="keywords" content="OpenOffice, Open Office, Apache OpenOffice, Apache Open Office, OpenOffice.org, Developer, Project, Website, Official, Writer, Calc, Impress, Draw, Base, ODF, Open Document Format">
    <!-- Facebook Meta Tags -->
    <meta property="og:url" content="https://openoffice.apache.org">
    <meta property="og:type" content="website">
    <meta property="og:title" content="Apache OpenOffice">
    <meta property="og:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta property="og:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Twitter Meta Tags -->
    <meta name="twitter:card" content="summary_large_image">
    <meta property="twitter:domain" content="openoffice.apache.org">
    <meta property="twitter:url" content="https://openoffice.apache.org">
    <meta name="twitter:title" content="Apache OpenOffice">
    <meta name="twitter:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="twitter:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Above Meta Tags Generated via https://www.opengraph.xyz -->
<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
<link rel="icon" href="/favicon.ico" type="image/x-icon" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body id="index" class="home">
  <div id="banner">
      <div id="bannerleft"><a alt="Apache OpenOffice" href="/">
          <img id="logo" alt="Apache OpenOffice" src="/images/AOO4_website_logo.png" height="60" width="161"/></a></div>
      <div id="bannercenter">The Free and Open Productivity Suite</div>
  </div>
  <div id="clear"></div>
  <nav class="navbar navbar-expand-sm navbar-dark bg-primary">
<button class="navbar-toggler" type="button"
        data-toggle="collapse" data-target="#navbarSupportedContent"
        aria-controls="navbarSupportedContent" aria-expanded="false"
        aria-label="Toggle navigation">
  <span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
  <ul class="navbar-nav mr-auto">
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="generalDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">General</a>
      <ul class="dropdown-menu" aria-labelledby="generalDropdown">
	<li><a class="dropdown-item" href="/index.html">About</a></li>
	<li><a class="dropdown-item" href="/downloads.html">Downloads</a></li>
	<li><a class="dropdown-item" href="/license.html">License</a></li>
	<li><a class="dropdown-item" href="/trademarks.html">Trademarks</a></li>
	<li><a class="dropdown-item" href="/press.html">Press</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/">OpenOffice.org</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="communityDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Community</a>
      <ul class="dropdown-menu" aria-labelledby="communityDropdown">
	<li><a class="dropdown-item" href="/get-involved.html">Get Involved</a></li>
	<li><a class="dropdown-item" href="/orientation/index.html">Orientation</a></li>
	<li><a class="dropdown-item" href="/mailing-lists.html">Mailing Lists</a></li>
	<li><a class="dropdown-item" href="/social.html">Social Networking</a></li>
	<li><a class="dropdown-item" href="/events.html">Events</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/support/">Support</a></li>
	<li><a class="dropdown-item" href="/native-lang.html">Native Language</a></li>
	<li><a class="dropdown-item" href="https://cwiki.apache.org/confluence/display/OOOUSERS/">Planning Wiki</a></li>
	<li><a class="dropdown-item" href="/people.html">People</a></li>
	<li><a class="dropdown-item" href="/community-faqs.html">Community FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="developmentDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Development</a>
      <ul class="dropdown-menu" aria-labelledby="developmentDropdown">
	<li><a class="dropdown-item" href="/source.html">Source Code</a></li>
	<li><a class="dropdown-item" href="/bug-tracking.html">Bug Tracking</a></li>
	<li><a class="dropdown-item" href="/qa.html">Quality Assurance</a></li>
	<li><a class="dropdown-item" href="/translate.html">Translation</a></li>
	<li><a class="dropdown-item" href="/website-local.html">Website</a></li>
	<li><a class="dropdown-item" href="/security.html">Security Reports</a></li>
	<li><a class="dropdown-item" href="/contributing-code.html">Contributing Code</a></li>
	<li><a class="dropdown-item" href="/developer-faqs.html">Developer FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="projectDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Project</a>
      <ul class="dropdown-menu" aria-labelledby="projectDropdown">
	<li><a class="dropdown-item" href="https://blogs.apache.org/OOo/">Project Blog</a></li>
	<li><a class="dropdown-item" href="/pmc-faqs.html">PMC FAQs</a></li>
      </ul>
    </li>
  </ul>
  <div class="navbar-nav" style="padding-top: 0.5rem;">
    <div class="nav-item dropdown dropdown-menu-right active">
      <a class="nav-link dropdown-toggle" href="#"
         role="button" data-toggle="dropdown" aria-haspopup="true"
         aria-expanded="false"><img src="https://www.apache.org/foundation/press/kit/feather.svg"
				    width="32" height="32" class="d-inline-block align-top"
				    alt="Apache Feather">The ASF</a>
      <div class="dropdown-menu dropdown-menu-right">
	<a class="dropdown-item" href="https://www.apache.org/">Website</a>
	<a class="dropdown-item" href="https://www.apache.org/licenses/">License</a>
	<a class="dropdown-item" href="https://www.apache.org/security/">Security</a>
	<a class="dropdown-item" href="https://www.apache.org/events/current-event">Events</a>
	<a class="dropdown-item" href="https://www.openoffice.org/donations.html">Donations</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/thanks.html">Thanks</a>
      </div>
    </div>
  </div>
</div>  </nav>
  <div id="contenta">
    <br/>
    <p>In this Orientation Module you will learn about tools and servers that are part of the daily operations of the project. You will interact with many of these on a regular basis, or at least hear them discussed on the lists, so it is important to know what they are, and where to go if you need more information or run into problems.</p>
<ol>
<li>
<p>First, Please send an email to <a href="mailto:recruitment@openoffice.apache.org?subject=Starting%20Infrastructure%20Module">recruitment@openoffice.apache.org</a> to let us know you are working on this module.</p>
</li>
<li>
<p>List of tools and services we use</p>
<ul>
<li>
<p>ezmlm: This is the time-tested EZ Mailing List Manager application that manages our mailing lists. You control ezmlm by sending commands to a list address. For example, if the list address is <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a> then you subscribe to the list with the command dev-<strong>subscribe</strong>@openoffice.apache.org. Some other popular commands are listed <a href="https://www.apache.org/foundation/mailinglists.html">here</a>. You can get a full list of commands available to you by sending the <em>help</em> command, as in dev-<strong>help</strong>@openoffice.apache.org. Each list has moderators who have additional capabilities. You can find the moderators for our lists <a href="/pmc-faqs.html#mailing-lists">here</a>.</p>
</li>
<li>
<p>Our two websites: <a href="https://www.openoffice.org">www.openoffice.org</a> and <a href="/">openoffice.apache.org</a>. Why two? There is some logic here, although it is not perfectly executed (yet). The <a href="http://www.openoffice.org">www.openoffice.org</a> website is our primary user-facing website. It is where we put content intended for end-users to use, so downloads, product documentations, support and other related materials. The openoffice.apache.org website, on the other hand, is the main portal for project members, the contributors to the project. We run the project on openoffice.apache.org, and the <a href="http://www.openoffice.org">www.openoffice.org</a> website is a service we provide to users.</p>
</li>
<li>
<p>MediaWiki (also called MWiki) is used for the wiki on the <a href="https://wiki.openoffice.org/wiki/Main_Page">wiki.openoffice.org</a> website. We use MWiki for many of the user-facing pages on the website, especially in the areas of documentation and support. If you are familiar with Wikipedia and the syntax used for authoring articles there, then you will find our MediaWiki very easy to use, since Wikipedia also uses MediaWiki. If you are new to MediaWiki please read over this <a href="https://meta.wikimedia.org/wiki/Help:Editing">introduction to the basics</a>.</p>
</li>
<li>
<p>Confluence Wiki (also called CWiki) is used for some <a href="https://cwiki.apache.org/confluence/display/OOOUSERS/Wiki+Home">project management webpages</a></p>
</li>
<li>
<p><a href="https://translate.apache.org">Pootle</a> is our translation management server, an online service used by translators to translate the UI and help files of OpenOffice into various languages. Unless you are involved with translations or builds you probably will never use Pootle. But you will hear it mentioned on the mailing lists.</p>
</li>
<li>
<p><strong>OBSOLETE</strong> Apache CMS (Content Management System) is the software that manages our websites, including the application of side-wide templates used to apply, for example, the common page footers that occur on each page). There is a web interface to the Apache CMS that makes it easy to make small updates to a page. If you are interested in adding or editing the website you can watch this video on the <a href="https://www.youtube.com/watch?v=7fvg1pfHLhE">Apache CMS's Anonymous Mode</a> now. Otherwise this is a valuable skill you can pick up later.</p>
</li>
<li>
<p><strong>OBSOLETE</strong> Subversion is the Version Control System (VCS) used by the project. Subversion is also its own Apache project. The source code for the OpenOffice product as well as the files for the websites are all stored in Subversion. Developers use Subversion heavily in their work. Advanced work in QA and bulk website changes also involve using Subversion.</p>
</li>
<li>
<p>phpBB is the software that runs our <a href="https://forum.openoffice.org/en/forum/">Community Forums</a>, used for technical support of our users.</p>
</li>
<li>
<p><a href="https://issues.apache.org/ooo/">Bugzilla</a> is used to track defect OpenOffice (bug) report.</p>
</li>
<li>
<p><a href="https://issues.apache.org/jira/">JIRA</a> is another issue tracking application. Some Apache projects use JIRA instead of Bugzilla. We mainly use JIRA when we need to raise an issue with another group at Apache that uses JIRA, for example the Apache Infrastructure Team.</p>
</li>
</ul>
</li>
<li>
<p>It is important to understand the role of the <a href="https://www.apache.org/dev/infrastructure.html">Apache Infrastructure Team</a> (Infra or Infra@. The Infrastructure team are essentially the system administrators for all Apache-wide servers and services, including many of the services described above. As you can imagine, with all the projects that are part of Apache, this is huge job. In order to support this number of projects and provide good service levels in this shared infrastructure environment, we align ourselves with the common services that are made available to other projects. In other words, we have a "menu" of services that we can enable for the project, and the ability to do some customization, within defined bounds, but we cannot easily use a service outside of that menu.</p>
</li>
<li>
<p>What to do if you have a problem:</p>
<ul>
<li>Questions on how to use the service: First, look for instructions on the website. If that fails, post a note to the dev mailing list for hints.</li>
<li>Outages: <a href="https://monitoring.apache.org/status/">Current status</a> is posted. You might also want to subscribe to Infra's <a href="https://twitter.com/infrabot">Twitter feed</a>. If you see an outage not noted there already, you can notify Infra via IRC channel #asfinfra on Freenode.</li>
<li>Requests to enhance or modify the service: Propose something on dev. Even though Infra is required to carry out some tasks, you still should get consensus first on the project's mailing list.</li>
</ul>
</li>
<li>
<p>Congratulations! You have completed this Module. Please send a note to <a href="mailto:recruitment@openoffice.apache.org?subject=Completed%20Infrastructure%20Module">recruitment@openoffice.apache.org</a> so we all know you have completed this level. This is also a good opportunity to send along any feedback or questions you might have on this Orientation Module.</p>
</li>
</ol>

  </div>

  <footer class="navbar-expand-lg navbar-light bg-light">
    <div class="footer" id="footer">
        <div class="container-fluid">
          Copyright &copy; 2011-2021 The Apache Software Foundation,
          Licensed under the
          <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0.</a> | <a href="/contact.html">Contact Us</a> | <a href="/terms.html">Terms of Use</a> | <a href="/privacy.html">Privacy</a>
          <br/>
          Apache, OpenOffice, OpenOffice.org and the seagull logo are registered trademarks of The Apache Software Foundation.
          The Apache feather logo is a trademark of The Apache Software Foundation.
          Other names appearing on the site may be trademarks of their respective owners.
        </div><!-- #container-fluid -->
        <div class="row container-fluid">
          <div class="col-sm">
            <a href="https://www.apache.org/">
              <img src="https://www.apache.org/img/asf_logo.png" alt="The Apache Software Foundation" style="border: 0; margin-top: 2px" width="200" height="82">
            </a>
          </div>
          <div class="col-sm center-align">
            <a href="https://www.apache.org/foundation/contributing.html">
              <img src="https://www.apache.org/images/SupportApache-small.png" alt="Support The ASF" height="80" width="80">
            </a>
          </div>
          <div class="col-sm right-align">
            <a class="acevent" data-format="wide" data-mode="light" data-event="random"></a>
          </div>
        </div>
    </div>
  </footer>
  <!-- Start load of stylesheets (will need to upgrade periodically) -->
  <link rel="stylesheet"
	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
	crossorigin="anonymous">
  <link rel="stylesheet"
	href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/3.0.1/github-markdown.min.css"
	crossorigin="anonymous">
  <link href="/theme/css/openoffice.css" rel="stylesheet" type="text/css">
  <!-- End stylesheets -->
  <!-- Start the loading of javascript frameworks (will need to upgrade periodically) -->
  <script src="https://www.apachecon.com/event-images/snippet.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.slim.min.js"
	  integrity="sha512-6ORWJX/LrnSjBzwefdNUyLCMTIsGoNP6NftMy2UAm1JBm6PRZCO1d7OHBStWpVFZLO+RerTvqX/Z9mBFfCJZ4A=="
	  crossorigin="anonymous"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
	  integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1"
	  crossorigin="anonymous"></script>
  <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
	  integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
	  crossorigin="anonymous"></script>
  <!-- End the loading of javascript frameworks -->

  <!-- Source: orientation/infrastructure.md; Template: page; Url: orientation/infrastructure.html -->
</body>
</html>