View Javadoc

1   package org.apache.continuum.purge;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.continuum.buildmanager.BuildsManager;
23  import org.apache.continuum.model.repository.DirectoryPurgeConfiguration;
24  import org.apache.continuum.model.repository.DistributedDirectoryPurgeConfiguration;
25  import org.apache.continuum.model.repository.LocalRepository;
26  import org.apache.continuum.model.repository.RepositoryPurgeConfiguration;
27  import org.apache.continuum.purge.task.PurgeTask;
28  import org.apache.continuum.taskqueue.manager.TaskQueueManager;
29  import org.apache.continuum.taskqueue.manager.TaskQueueManagerException;
30  import org.apache.maven.continuum.build.settings.SchedulesActivationException;
31  import org.apache.maven.continuum.build.settings.SchedulesActivator;
32  import org.apache.maven.continuum.model.project.Schedule;
33  import org.codehaus.plexus.taskqueue.TaskQueueException;
34  import org.slf4j.Logger;
35  import org.slf4j.LoggerFactory;
36  
37  import java.util.List;
38  
39  /**
40   * DefaultContinuumPurgeManager
41   *
42   * @author Maria Catherine Tan
43   * @version $Id: DefaultContinuumPurgeManager.java 1372260 2012-08-13 04:29:09Z brett $
44   * @plexus.component role="org.apache.continuum.purge.ContinuumPurgeManager" role-hint="default"
45   * @since 25 jul 07
46   */
47  public class DefaultContinuumPurgeManager
48      implements ContinuumPurgeManager
49  {
50      private static final Logger log = LoggerFactory.getLogger( DefaultContinuumPurgeManager.class );
51  
52      /**
53       * @plexus.requirement
54       */
55      private SchedulesActivator schedulesActivator;
56  
57      /**
58       * @plexus.requirement
59       */
60      private PurgeConfigurationService purgeConfigurationService;
61  
62      /**
63       * @plexus.requirement
64       */
65      private TaskQueueManager taskQueueManager;
66  
67      /**
68       * @plexus.requirement role-hint="parallel"
69       */
70      private BuildsManager parallelBuildsManager;
71  
72      public void purge( Schedule schedule )
73          throws ContinuumPurgeManagerException
74      {
75          List<RepositoryPurgeConfiguration> repoPurgeList = null;
76          List<DirectoryPurgeConfiguration> dirPurgeList = null;
77          List<DistributedDirectoryPurgeConfiguration> distributedDirPurgeList = null;
78  
79          repoPurgeList = purgeConfigurationService.getEnableRepositoryPurgeConfigurationsBySchedule( schedule.getId() );
80          dirPurgeList = purgeConfigurationService.getEnableDirectoryPurgeConfigurationsBySchedule( schedule.getId() );
81          distributedDirPurgeList = purgeConfigurationService.getEnableDistributedDirectoryPurgeConfigurationsBySchedule(
82              schedule.getId() );
83  
84          boolean hasRepoPurge = repoPurgeList != null && repoPurgeList.size() > 0;
85          boolean hasDirPurge = dirPurgeList != null && dirPurgeList.size() > 0;
86          boolean hasDitributedDirPurge = distributedDirPurgeList != null && distributedDirPurgeList.size() > 0;
87  
88          if ( hasRepoPurge )
89          {
90              for ( RepositoryPurgeConfiguration repoPurge : repoPurgeList )
91              {
92                  purgeRepository( repoPurge );
93              }
94          }
95  
96          if ( hasDirPurge )
97          {
98              for ( DirectoryPurgeConfiguration dirPurge : dirPurgeList )
99              {
100                 purgeDirectory( dirPurge );
101             }
102         }
103 
104         if ( hasDitributedDirPurge )
105         {
106             for ( DistributedDirectoryPurgeConfiguration dirPurge : distributedDirPurgeList )
107             {
108                 purgeDistributedDirectory( dirPurge );
109             }
110         }
111 
112         if ( !hasRepoPurge && !hasDirPurge && !hasDitributedDirPurge )
113         {
114             // This purge is not enable for a purge process.
115             try
116             {
117                 schedulesActivator.unactivateOrphanPurgeSchedule( schedule );
118             }
119             catch ( SchedulesActivationException e )
120             {
121                 log.debug( String.format( "Can't unactivate orphan schedule '%s' for purgeConfiguration",
122                                           schedule.getName() ) );
123             }
124         }
125     }
126 
127     public void purgeRepository( RepositoryPurgeConfiguration repoPurge )
128         throws ContinuumPurgeManagerException
129     {
130         try
131         {
132             LocalRepository repository = repoPurge.getRepository();
133 
134             // do not purge if repository is in use and if repository is already in purge queue
135             if ( !taskQueueManager.isRepositoryInUse( repository.getId() ) && !taskQueueManager.isInPurgeQueue(
136                 repoPurge.getId() ) )
137             {
138                 taskQueueManager.getPurgeQueue().put( new PurgeTask( repoPurge.getId() ) );
139             }
140         }
141         catch ( TaskQueueException e )
142         {
143             throw new ContinuumPurgeManagerException( "Error while enqueuing repository", e );
144         }
145         catch ( TaskQueueManagerException e )
146         {
147             throw new ContinuumPurgeManagerException( e.getMessage(), e );
148         }
149     }
150 
151     public void purgeDirectory( DirectoryPurgeConfiguration dirPurge )
152         throws ContinuumPurgeManagerException
153     {
154         try
155         {
156             if ( "releases".equals( dirPurge.getDirectoryType() ) )
157             {
158                 // do not purge if release in progress
159                 if ( !taskQueueManager.releaseInProgress() && !taskQueueManager.isInPurgeQueue( dirPurge.getId() ) )
160                 {
161                     taskQueueManager.getPurgeQueue().put( new PurgeTask( dirPurge.getId() ) );
162                 }
163             }
164             else if ( "buildOutput".equals( dirPurge.getDirectoryType() ) )
165             {
166                 // do not purge if build in progress
167                 if ( !parallelBuildsManager.isBuildInProgress() && !taskQueueManager.isInPurgeQueue(
168                     dirPurge.getId() ) )
169                 {
170                     taskQueueManager.getPurgeQueue().put( new PurgeTask( dirPurge.getId() ) );
171                 }
172             }
173 
174         }
175         catch ( TaskQueueException e )
176         {
177             throw new ContinuumPurgeManagerException( "Error while enqueuing directory", e );
178         }
179         catch ( TaskQueueManagerException e )
180         {
181             throw new ContinuumPurgeManagerException( e.getMessage(), e );
182         }
183     }
184 
185     public void purgeDistributedDirectory( DistributedDirectoryPurgeConfiguration dirPurge )
186         throws ContinuumPurgeManagerException
187     {
188         try
189         {
190             taskQueueManager.getPurgeQueue().put( new PurgeTask( dirPurge.getId() ) );
191         }
192         catch ( TaskQueueException e )
193         {
194             throw new ContinuumPurgeManagerException( "Error while enqueuing distributed directory", e );
195         }
196     }
197 
198 }