 ------
 Force Project Build
 ------
 ------
 2010-02-18
 ------

~~ 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.

Force Project Build

    Occasionally you may want to force a build outside of the regular schedule.
    When builds are triggered manually, the following happens:

    * Projects are updated from the SCM.
      These are queued under the <<Prepare Build Queues>> section in <<Queues>> page.

    * Builds of the projects are executed.
      These are queued under the <<Build Queues>> in <<Queues>> page.

    []

    To manually build a project perform the following steps:

    [[1]] Click <<Show Project Groups>>.

    [[2]] Click the project group link of the project you want to build.
    This will put you on the <<Summary>> page of the project group.

    [[3]] You can click <<Build all projects>> button under <<Group Actions>> to build all
    the projects in the project group.

[../../images/force_build.png] Project Group Actions

    [[4]] To build an individual project, you can click on the build icon that is found
    along the row of the project you want to build. It is the first icon on the right of
    the project name. This will execute the default build goal you have defined for that project.

    To build selected projects, check the box beside the name of the project,
    then click the <<Build Project(s)>> button.

    If you want to build the project according to a specific build goal other than the
    default build goal, click on the project name to go to the <<Project's Information>> page.
    All build goal definitions for the project are listed under the <<Build Definitions>> section.
    Click on the build icon to the right of the specific build goal you want to execute.

    []
    
    *Note* In a distributed build setup, the project builds are not executed if no build agent is
    configured or if a build agent group with no build agent, is configured in the build environment 
    that is attached to the project's build definition.

    To view the results of the build, refer to {{{./build_results.html}Build Results Management}}.
