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.dao.DirectoryPurgeConfigurationDao;
23  import org.apache.continuum.dao.DistributedDirectoryPurgeConfigurationDao;
24  import org.apache.continuum.dao.LocalRepositoryDao;
25  import org.apache.continuum.dao.RepositoryPurgeConfigurationDao;
26  import org.apache.continuum.model.repository.AbstractPurgeConfiguration;
27  import org.apache.continuum.model.repository.DirectoryPurgeConfiguration;
28  import org.apache.continuum.model.repository.DistributedDirectoryPurgeConfiguration;
29  import org.apache.continuum.model.repository.LocalRepository;
30  import org.apache.continuum.model.repository.RepositoryPurgeConfiguration;
31  import org.apache.continuum.purge.repository.content.RepositoryManagedContent;
32  import org.apache.maven.continuum.store.ContinuumObjectNotFoundException;
33  import org.apache.maven.continuum.store.ContinuumStoreException;
34  import org.codehaus.plexus.PlexusConstants;
35  import org.codehaus.plexus.PlexusContainer;
36  import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
37  import org.codehaus.plexus.context.Context;
38  import org.codehaus.plexus.context.ContextException;
39  import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
40  
41  import java.util.ArrayList;
42  import java.util.List;
43  
44  /**
45   * DefaultPurgeConfigurationService
46   *
47   * @author Maria Catherine Tan
48   * @version $Id: DefaultPurgeConfigurationService.java 1372260 2012-08-13 04:29:09Z brett $
49   * @plexus.component role="org.apache.continuum.purge.PurgeConfigurationService" role-hint="default"
50   * @since 25 jul 07
51   */
52  public class DefaultPurgeConfigurationService
53      implements PurgeConfigurationService, Contextualizable
54  {
55      /**
56       * @plexus.requirement
57       */
58      private DirectoryPurgeConfigurationDao directoryPurgeConfigurationDao;
59  
60      /**
61       * @plexus.requirement
62       */
63      private LocalRepositoryDao localRepositoryDao;
64  
65      /**
66       * @plexus.requirement
67       */
68      private RepositoryPurgeConfigurationDao repositoryPurgeConfigurationDao;
69  
70      /**
71       * @plexus.requirement
72       */
73      private DistributedDirectoryPurgeConfigurationDao distributedDirectoryPurgeConfigurationDao;
74  
75      private PlexusContainer container;
76  
77      public AbstractPurgeConfiguration addPurgeConfiguration( AbstractPurgeConfiguration purgeConfig )
78          throws PurgeConfigurationServiceException
79      {
80          AbstractPurgeConfiguration purgeConfiguration = null;
81  
82          if ( purgeConfig instanceof RepositoryPurgeConfiguration )
83          {
84              purgeConfiguration = addRepositoryPurgeConfiguration( (RepositoryPurgeConfiguration) purgeConfig );
85          }
86          else if ( purgeConfig instanceof DirectoryPurgeConfiguration )
87          {
88              purgeConfiguration = addDirectoryPurgeConfiguration( (DirectoryPurgeConfiguration) purgeConfig );
89          }
90          else if ( purgeConfig instanceof DistributedDirectoryPurgeConfiguration )
91          {
92              purgeConfiguration = addDistributedDirectoryPurgeConfiguration(
93                  (DistributedDirectoryPurgeConfiguration) purgeConfig );
94          }
95  
96          return purgeConfiguration;
97      }
98  
99      public void updatePurgeConfiguration( AbstractPurgeConfiguration purgeConfig )
100         throws PurgeConfigurationServiceException
101     {
102         if ( purgeConfig instanceof RepositoryPurgeConfiguration )
103         {
104             updateRepositoryPurgeConfiguration( (RepositoryPurgeConfiguration) purgeConfig );
105         }
106         else if ( purgeConfig instanceof DirectoryPurgeConfiguration )
107         {
108             updateDirectoryPurgeConfiguration( (DirectoryPurgeConfiguration) purgeConfig );
109         }
110         else if ( purgeConfig instanceof DistributedDirectoryPurgeConfiguration )
111         {
112             updateDistributedDirectoryPurgeConfiguration( (DistributedDirectoryPurgeConfiguration) purgeConfig );
113         }
114     }
115 
116     public void removePurgeConfiguration( int purgeConfigId )
117         throws PurgeConfigurationServiceException
118     {
119         AbstractPurgeConfiguration purgeConfig = getPurgeConfiguration( purgeConfigId );
120 
121         if ( purgeConfig instanceof RepositoryPurgeConfiguration )
122         {
123             removeRepositoryPurgeConfiguration( (RepositoryPurgeConfiguration) purgeConfig );
124         }
125         else if ( purgeConfig instanceof DirectoryPurgeConfiguration )
126         {
127             removeDirectoryPurgeConfiguration( (DirectoryPurgeConfiguration) purgeConfig );
128         }
129         else if ( purgeConfig instanceof DistributedDirectoryPurgeConfiguration )
130         {
131             removeDistributedDirectoryPurgeConfiguration( (DistributedDirectoryPurgeConfiguration) purgeConfig );
132         }
133     }
134 
135     public DirectoryPurgeConfiguration addDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
136         throws PurgeConfigurationServiceException
137     {
138         DirectoryPurgeConfiguration dirPurgeConfig;
139 
140         try
141         {
142             dirPurgeConfig = directoryPurgeConfigurationDao.addDirectoryPurgeConfiguration( dirPurge );
143         }
144         catch ( ContinuumStoreException e )
145         {
146             throw new PurgeConfigurationServiceException( e.getMessage(), e );
147         }
148 
149         return dirPurgeConfig;
150     }
151 
152     public RepositoryPurgeConfiguration addRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
153         throws PurgeConfigurationServiceException
154     {
155         RepositoryPurgeConfiguration repoPurgeConfig;
156 
157         try
158         {
159             repoPurgeConfig = repositoryPurgeConfigurationDao.addRepositoryPurgeConfiguration( repoPurge );
160         }
161         catch ( ContinuumStoreException e )
162         {
163             throw new PurgeConfigurationServiceException( e.getMessage(), e );
164         }
165 
166         return repoPurgeConfig;
167     }
168 
169     public RepositoryPurgeConfiguration getDefaultPurgeConfigurationForRepository( int repositoryId )
170     {
171         List<RepositoryPurgeConfiguration> purgeConfigs = getRepositoryPurgeConfigurationsByRepository( repositoryId );
172 
173         for ( RepositoryPurgeConfiguration purgeConfig : purgeConfigs )
174         {
175             if ( purgeConfig.isDefaultPurge() )
176             {
177                 return purgeConfig;
178             }
179         }
180 
181         return null;
182     }
183 
184     public List<DirectoryPurgeConfiguration> getAllDirectoryPurgeConfigurations()
185     {
186         return directoryPurgeConfigurationDao.getAllDirectoryPurgeConfigurations();
187     }
188 
189     public List<RepositoryPurgeConfiguration> getAllRepositoryPurgeConfigurations()
190     {
191         return repositoryPurgeConfigurationDao.getAllRepositoryPurgeConfigurations();
192     }
193 
194     public List<AbstractPurgeConfiguration> getAllPurgeConfigurations()
195     {
196         List<RepositoryPurgeConfiguration> repoPurge = getAllRepositoryPurgeConfigurations();
197         List<DirectoryPurgeConfiguration> dirPurge = getAllDirectoryPurgeConfigurations();
198 
199         List<AbstractPurgeConfiguration> allPurgeConfigs = new ArrayList<AbstractPurgeConfiguration>();
200 
201         allPurgeConfigs.addAll( repoPurge );
202         allPurgeConfigs.addAll( dirPurge );
203 
204         return allPurgeConfigs;
205     }
206 
207     public DirectoryPurgeConfiguration getDefaultPurgeConfigurationForDirectoryType( String directoryType )
208     {
209         List<DirectoryPurgeConfiguration> purgeConfigs =
210             directoryPurgeConfigurationDao.getDirectoryPurgeConfigurationsByType( directoryType );
211 
212         for ( DirectoryPurgeConfiguration purgeConfig : purgeConfigs )
213         {
214             if ( purgeConfig.isDefaultPurge() )
215             {
216                 return purgeConfig;
217             }
218         }
219 
220         return null;
221     }
222 
223     public List<DirectoryPurgeConfiguration> getDirectoryPurgeConfigurationsByLocation( String location )
224     {
225         return directoryPurgeConfigurationDao.getDirectoryPurgeConfigurationsByLocation( location );
226     }
227 
228     public List<DirectoryPurgeConfiguration> getDirectoryPurgeConfigurationsBySchedule( int scheduleId )
229     {
230         return directoryPurgeConfigurationDao.getDirectoryPurgeConfigurationsBySchedule( scheduleId );
231     }
232 
233     public List<DirectoryPurgeConfiguration> getEnableDirectoryPurgeConfigurationsBySchedule( int scheduleId )
234     {
235         return directoryPurgeConfigurationDao.getEnableDirectoryPurgeConfigurationsBySchedule( scheduleId );
236     }
237 
238     public List<RepositoryPurgeConfiguration> getRepositoryPurgeConfigurationsByRepository( int repositoryId )
239     {
240         return repositoryPurgeConfigurationDao.getRepositoryPurgeConfigurationsByLocalRepository( repositoryId );
241     }
242 
243     public List<RepositoryPurgeConfiguration> getRepositoryPurgeConfigurationsBySchedule( int scheduleId )
244     {
245         return repositoryPurgeConfigurationDao.getRepositoryPurgeConfigurationsBySchedule( scheduleId );
246     }
247 
248     public List<RepositoryPurgeConfiguration> getEnableRepositoryPurgeConfigurationsBySchedule( int scheduleId )
249     {
250         return repositoryPurgeConfigurationDao.getEnableRepositoryPurgeConfigurationsBySchedule( scheduleId );
251     }
252 
253     public void removeDirectoryPurgeConfiguration( DirectoryPurgeConfiguration purgeConfig )
254         throws PurgeConfigurationServiceException
255     {
256         try
257         {
258             directoryPurgeConfigurationDao.removeDirectoryPurgeConfiguration( purgeConfig );
259         }
260         catch ( ContinuumStoreException e )
261         {
262             throw new PurgeConfigurationServiceException( e.getMessage(), e );
263         }
264     }
265 
266     public void removeRepositoryPurgeConfiguration( RepositoryPurgeConfiguration purgeConfig )
267         throws PurgeConfigurationServiceException
268     {
269         try
270         {
271             repositoryPurgeConfigurationDao.removeRepositoryPurgeConfiguration( purgeConfig );
272         }
273         catch ( ContinuumStoreException e )
274         {
275             throw new PurgeConfigurationServiceException( e.getMessage(), e );
276         }
277     }
278 
279     public void updateDirectoryPurgeConfiguration( DirectoryPurgeConfiguration purgeConfig )
280         throws PurgeConfigurationServiceException
281     {
282         try
283         {
284             directoryPurgeConfigurationDao.updateDirectoryPurgeConfiguration( purgeConfig );
285         }
286         catch ( ContinuumStoreException e )
287         {
288             throw new PurgeConfigurationServiceException( e.getMessage(), e );
289         }
290     }
291 
292     public void updateRepositoryPurgeConfiguration( RepositoryPurgeConfiguration purgeConfig )
293         throws PurgeConfigurationServiceException
294     {
295         try
296         {
297             repositoryPurgeConfigurationDao.updateRepositoryPurgeConfiguration( purgeConfig );
298         }
299         catch ( ContinuumStoreException e )
300         {
301             throw new PurgeConfigurationServiceException( e.getMessage(), e );
302         }
303     }
304 
305     public DirectoryPurgeConfiguration getDirectoryPurgeConfiguration( int purgeConfigId )
306         throws PurgeConfigurationServiceException
307     {
308         try
309         {
310             return directoryPurgeConfigurationDao.getDirectoryPurgeConfiguration( purgeConfigId );
311         }
312         catch ( ContinuumObjectNotFoundException e )
313         {
314             throw new PurgeConfigurationServiceException( e.getMessage(), e );
315         }
316         catch ( ContinuumStoreException e )
317         {
318             throw new PurgeConfigurationServiceException( e.getMessage(), e );
319         }
320     }
321 
322     public RepositoryPurgeConfiguration getRepositoryPurgeConfiguration( int purgeConfigId )
323         throws PurgeConfigurationServiceException
324     {
325         try
326         {
327             return repositoryPurgeConfigurationDao.getRepositoryPurgeConfiguration( purgeConfigId );
328         }
329         catch ( ContinuumObjectNotFoundException e )
330         {
331             throw new PurgeConfigurationServiceException( e.getMessage(), e );
332         }
333         catch ( ContinuumStoreException e )
334         {
335             throw new PurgeConfigurationServiceException( e.getMessage(), e );
336         }
337     }
338 
339     public AbstractPurgeConfiguration getPurgeConfiguration( int purgeConfigId )
340     {
341         AbstractPurgeConfiguration purgeConfig = null;
342 
343         try
344         {
345             purgeConfig = getRepositoryPurgeConfiguration( purgeConfigId );
346         }
347         catch ( PurgeConfigurationServiceException e )
348         {
349             // purgeConfigId is not of type repository purge configuration
350         }
351 
352         if ( purgeConfig == null )
353         {
354             try
355             {
356                 purgeConfig = getDirectoryPurgeConfiguration( purgeConfigId );
357             }
358             catch ( PurgeConfigurationServiceException e )
359             {
360                 // purgeConfigId is not of type directory purge configuration
361             }
362         }
363 
364         if ( purgeConfig == null )
365         {
366             try
367             {
368                 purgeConfig = getDistributedDirectoryPurgeConfiguration( purgeConfigId );
369             }
370             catch ( PurgeConfigurationServiceException e )
371             {
372                 // purgeConfigId is not of type directory purge configuration
373             }
374         }
375 
376         return purgeConfig;
377     }
378 
379     public RepositoryManagedContent getManagedRepositoryContent( int repositoryId )
380         throws PurgeConfigurationServiceException
381     {
382         try
383         {
384             LocalRepository repository = localRepositoryDao.getLocalRepository( repositoryId );
385 
386             RepositoryManagedContent repoContent;
387 
388             repoContent = (RepositoryManagedContent) container.lookup( RepositoryManagedContent.class,
389                                                                        repository.getLayout() );
390             repoContent.setRepository( repository );
391 
392             return repoContent;
393         }
394         catch ( ContinuumObjectNotFoundException e )
395         {
396             throw new PurgeConfigurationServiceException(
397                 "Error retrieving managed repository content for: " + repositoryId, e );
398         }
399         catch ( ContinuumStoreException e )
400         {
401             throw new PurgeConfigurationServiceException(
402                 "Error retrieving managed repository content for: " + repositoryId, e );
403         }
404         catch ( ComponentLookupException e )
405         {
406             throw new PurgeConfigurationServiceException(
407                 "Error retrieving managed repository content for: " + repositoryId, e );
408         }
409     }
410 
411     public List<DistributedDirectoryPurgeConfiguration> getAllDistributedDirectoryPurgeConfigurations()
412     {
413         return distributedDirectoryPurgeConfigurationDao.getAllDistributedDirectoryPurgeConfigurations();
414     }
415 
416     public DistributedDirectoryPurgeConfiguration addDistributedDirectoryPurgeConfiguration(
417         DistributedDirectoryPurgeConfiguration dirPurge )
418         throws PurgeConfigurationServiceException
419     {
420         DistributedDirectoryPurgeConfiguration dirPurgeConfig;
421 
422         try
423         {
424             dirPurgeConfig = distributedDirectoryPurgeConfigurationDao.addDistributedDirectoryPurgeConfiguration(
425                 dirPurge );
426         }
427         catch ( ContinuumStoreException e )
428         {
429             throw new PurgeConfigurationServiceException( e.getMessage(), e );
430         }
431 
432         return dirPurgeConfig;
433 
434     }
435 
436     public DistributedDirectoryPurgeConfiguration getDistributedDirectoryPurgeConfiguration( int dirPurgeId )
437         throws PurgeConfigurationServiceException
438     {
439         try
440         {
441             return distributedDirectoryPurgeConfigurationDao.getDistributedDirectoryPurgeConfiguration( dirPurgeId );
442         }
443         catch ( ContinuumObjectNotFoundException e )
444         {
445             throw new PurgeConfigurationServiceException( e.getMessage(), e );
446         }
447         catch ( ContinuumStoreException e )
448         {
449             throw new PurgeConfigurationServiceException( e.getMessage(), e );
450         }
451     }
452 
453     public void updateDistributedDirectoryPurgeConfiguration( DistributedDirectoryPurgeConfiguration dirPurge )
454         throws PurgeConfigurationServiceException
455     {
456         try
457         {
458             distributedDirectoryPurgeConfigurationDao.updateDistributedDirectoryPurgeConfiguration( dirPurge );
459         }
460         catch ( ContinuumStoreException e )
461         {
462             throw new PurgeConfigurationServiceException( e.getMessage(), e );
463         }
464     }
465 
466     public void removeDistributedDirectoryPurgeConfiguration( DistributedDirectoryPurgeConfiguration purgeConfig )
467         throws PurgeConfigurationServiceException
468     {
469         try
470         {
471             distributedDirectoryPurgeConfigurationDao.removeDistributedDirectoryPurgeConfiguration( purgeConfig );
472         }
473         catch ( ContinuumStoreException e )
474         {
475             throw new PurgeConfigurationServiceException( e.getMessage(), e );
476         }
477     }
478 
479     public List<DistributedDirectoryPurgeConfiguration> getEnableDistributedDirectoryPurgeConfigurationsBySchedule(
480         int scheduleId )
481     {
482         return distributedDirectoryPurgeConfigurationDao.getEnableDistributedDirectoryPurgeConfigurationsBySchedule(
483             scheduleId );
484     }
485 
486     public void contextualize( Context context )
487         throws ContextException
488     {
489         container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
490     }
491 }