View Javadoc

1   package org.apache.maven.continuum.xmlrpc.client;
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.xmlrpc.release.ContinuumReleaseResult;
23  import org.apache.continuum.xmlrpc.repository.DirectoryPurgeConfiguration;
24  import org.apache.continuum.xmlrpc.repository.LocalRepository;
25  import org.apache.continuum.xmlrpc.repository.RepositoryPurgeConfiguration;
26  import org.apache.continuum.xmlrpc.utils.BuildTrigger;
27  import org.apache.maven.continuum.xmlrpc.ContinuumService;
28  import org.apache.maven.continuum.xmlrpc.project.AddingResult;
29  import org.apache.maven.continuum.xmlrpc.project.BuildAgentConfiguration;
30  import org.apache.maven.continuum.xmlrpc.project.BuildAgentGroupConfiguration;
31  import org.apache.maven.continuum.xmlrpc.project.BuildDefinition;
32  import org.apache.maven.continuum.xmlrpc.project.BuildDefinitionTemplate;
33  import org.apache.maven.continuum.xmlrpc.project.BuildProjectTask;
34  import org.apache.maven.continuum.xmlrpc.project.BuildResult;
35  import org.apache.maven.continuum.xmlrpc.project.BuildResultSummary;
36  import org.apache.maven.continuum.xmlrpc.project.ContinuumProjectState;
37  import org.apache.maven.continuum.xmlrpc.project.Project;
38  import org.apache.maven.continuum.xmlrpc.project.ProjectGroup;
39  import org.apache.maven.continuum.xmlrpc.project.ProjectGroupSummary;
40  import org.apache.maven.continuum.xmlrpc.project.ProjectNotifier;
41  import org.apache.maven.continuum.xmlrpc.project.ProjectScmRoot;
42  import org.apache.maven.continuum.xmlrpc.project.ProjectSummary;
43  import org.apache.maven.continuum.xmlrpc.project.ReleaseListenerSummary;
44  import org.apache.maven.continuum.xmlrpc.project.Schedule;
45  import org.apache.maven.continuum.xmlrpc.system.Installation;
46  import org.apache.maven.continuum.xmlrpc.system.Profile;
47  import org.apache.maven.continuum.xmlrpc.system.SystemConfiguration;
48  import org.apache.xmlrpc.client.XmlRpcClient;
49  import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
50  import org.apache.xmlrpc.client.XmlRpcCommonsTransportFactory;
51  import org.apache.xmlrpc.client.util.ClientFactory;
52  
53  import java.net.URL;
54  import java.util.Hashtable;
55  import java.util.List;
56  import java.util.Map;
57  import java.util.Properties;
58  
59  /**
60   * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
61   * @version $Id: ContinuumXmlRpcClient.java 1372260 2012-08-13 04:29:09Z brett $
62   */
63  public class ContinuumXmlRpcClient
64      implements ContinuumService
65  {
66      private final ContinuumService continuum;
67  
68      private static Hashtable<Integer, String> statusMap;
69  
70      static
71      {
72          statusMap = new Hashtable<Integer, String>();
73          statusMap.put( ContinuumProjectState.NEW, "New" );
74          statusMap.put( ContinuumProjectState.CHECKEDOUT, "New" );
75          statusMap.put( ContinuumProjectState.OK, "OK" );
76          statusMap.put( ContinuumProjectState.FAILED, "Failed" );
77          statusMap.put( ContinuumProjectState.ERROR, "Error" );
78          statusMap.put( ContinuumProjectState.BUILDING, "Building" );
79          statusMap.put( ContinuumProjectState.CHECKING_OUT, "Checking out" );
80          statusMap.put( ContinuumProjectState.UPDATING, "Updating" );
81          statusMap.put( ContinuumProjectState.WARNING, "Warning" );
82      }
83  
84      public ContinuumXmlRpcClient( URL serviceUrl )
85      {
86          this( serviceUrl, null, null );
87      }
88  
89      public ContinuumXmlRpcClient( URL serviceUrl, String login, String password )
90      {
91          XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl()
92          {
93              public boolean isEnabledForExtensions()
94              {
95                  return true;
96              }
97          };
98  
99          if ( login != null )
100         {
101             config.setBasicUserName( login );
102             config.setBasicPassword( password );
103         }
104         config.setServerURL( serviceUrl );
105 
106         XmlRpcClient client = new XmlRpcClient();
107         client.setTransportFactory( new XmlRpcCommonsTransportFactory( client ) );
108         client.setConfig( config );
109         ClientFactory factory = new ClientFactory( client );
110         continuum = (ContinuumService) factory.newInstance( ContinuumService.class );
111     }
112 
113     public boolean ping()
114         throws Exception
115     {
116         return continuum.ping();
117     }
118 
119     // ----------------------------------------------------------------------
120     // Projects
121     // ----------------------------------------------------------------------
122 
123     public List<ProjectSummary> getProjects( int projectGroupId )
124         throws Exception
125     {
126         return continuum.getProjects( projectGroupId );
127     }
128 
129     public ProjectSummary getProjectSummary( int projectId )
130         throws Exception
131     {
132         return continuum.getProjectSummary( projectId );
133     }
134 
135     public Project getProjectWithAllDetails( int projectId )
136         throws Exception
137     {
138         return continuum.getProjectWithAllDetails( projectId );
139     }
140 
141     public int removeProject( int projectId )
142         throws Exception
143     {
144         return continuum.removeProject( projectId );
145     }
146 
147     public ProjectSummary updateProject( ProjectSummary project )
148         throws Exception
149     {
150         return continuum.updateProject( project );
151     }
152 
153     public ProjectSummary refreshProjectSummary( ProjectSummary project )
154         throws Exception
155     {
156         if ( project == null )
157         {
158             return null;
159         }
160         return getProjectSummary( project.getId() );
161     }
162 
163     public Project refreshProjectWithAllDetails( ProjectSummary project )
164         throws Exception
165     {
166         if ( project == null )
167         {
168             return null;
169         }
170         return getProjectWithAllDetails( project.getId() );
171     }
172 
173     // ----------------------------------------------------------------------
174     // Projects Groups
175     // ----------------------------------------------------------------------
176 
177     public List<ProjectGroupSummary> getAllProjectGroups()
178         throws Exception
179     {
180         return continuum.getAllProjectGroups();
181     }
182 
183     public List<ProjectGroup> getAllProjectGroupsWithAllDetails()
184         throws Exception
185     {
186         return continuum.getAllProjectGroupsWithAllDetails();
187     }
188 
189     /**
190      * @deprecated
191      */
192     public List<ProjectGroup> getAllProjectGroupsWithProjects()
193         throws Exception
194     {
195         return getAllProjectGroupsWithAllDetails();
196     }
197 
198     public ProjectGroupSummary getProjectGroupSummary( int projectGroupId )
199         throws Exception
200     {
201         return continuum.getProjectGroupSummary( projectGroupId );
202     }
203 
204     public ProjectGroup getProjectGroupWithProjects( int projectGroupId )
205         throws Exception
206     {
207         return continuum.getProjectGroupWithProjects( projectGroupId );
208     }
209 
210     public int removeProjectGroup( int projectGroupId )
211         throws Exception
212     {
213         return continuum.removeProjectGroup( projectGroupId );
214     }
215 
216     public ProjectGroupSummary refreshProjectGroupSummary( ProjectGroupSummary projectGroup )
217         throws Exception
218     {
219         if ( projectGroup == null )
220         {
221             return null;
222         }
223         return getProjectGroupSummary( projectGroup.getId() );
224     }
225 
226     public ProjectGroup refreshProjectGroupSummaryWithProjects( ProjectGroupSummary projectGroup )
227         throws Exception
228     {
229         if ( projectGroup == null )
230         {
231             return null;
232         }
233         return getProjectGroupWithProjects( projectGroup.getId() );
234     }
235 
236     public ProjectGroupSummary updateProjectGroup( ProjectGroupSummary projectGroup )
237         throws Exception
238     {
239         return continuum.updateProjectGroup( projectGroup );
240     }
241 
242     public ProjectGroupSummary addProjectGroup( ProjectGroupSummary pg )
243         throws Exception
244     {
245         return addProjectGroup( pg.getName(), pg.getGroupId(), pg.getDescription() );
246     }
247 
248     public ProjectGroupSummary addProjectGroup( String groupName, String groupId, String description )
249         throws Exception
250     {
251         return continuum.addProjectGroup( groupName, groupId, description );
252     }
253 
254     // ----------------------------------------------------------------------
255     // Build Definitions
256     // ----------------------------------------------------------------------
257 
258     public List<BuildDefinition> getBuildDefinitionsForProject( int projectId )
259         throws Exception
260     {
261         return continuum.getBuildDefinitionsForProject( projectId );
262     }
263 
264     public List<BuildDefinition> getBuildDefinitionsForProjectGroup( int projectGroupId )
265         throws Exception
266     {
267         return continuum.getBuildDefinitionsForProjectGroup( projectGroupId );
268     }
269 
270     public BuildDefinition updateBuildDefinitionForProject( int projectId, BuildDefinition buildDef )
271         throws Exception
272     {
273         return continuum.updateBuildDefinitionForProject( projectId, buildDef );
274     }
275 
276     public BuildDefinition updateBuildDefinitionForProjectGroup( int projectGroupId, BuildDefinition buildDef )
277         throws Exception
278     {
279         return continuum.updateBuildDefinitionForProjectGroup( projectGroupId, buildDef );
280     }
281 
282     public int removeBuildDefinitionFromProjectGroup( int projectGroupId, int buildDefinitionId )
283         throws Exception
284     {
285         return continuum.removeBuildDefinitionFromProjectGroup( projectGroupId, buildDefinitionId );
286     }
287 
288     public BuildDefinition addBuildDefinitionToProject( int projectId, BuildDefinition buildDef )
289         throws Exception
290     {
291         return continuum.addBuildDefinitionToProject( projectId, buildDef );
292     }
293 
294     public BuildDefinition addBuildDefinitionToProjectGroup( int projectGroupId, BuildDefinition buildDef )
295         throws Exception
296     {
297         return continuum.addBuildDefinitionToProjectGroup( projectGroupId, buildDef );
298     }
299 
300     public List<BuildDefinitionTemplate> getBuildDefinitionTemplates()
301         throws Exception
302     {
303         return continuum.getBuildDefinitionTemplates();
304     }
305 
306     // ----------------------------------------------------------------------
307     // Building
308     // ----------------------------------------------------------------------
309 
310     public int addProjectToBuildQueue( int projectId )
311         throws Exception
312     {
313         return continuum.addProjectToBuildQueue( projectId );
314     }
315 
316     public int addProjectToBuildQueue( int projectId, int buildDefinitionId )
317         throws Exception
318     {
319         return continuum.addProjectToBuildQueue( projectId, buildDefinitionId );
320     }
321 
322     public int buildProject( int projectId )
323         throws Exception
324     {
325         return continuum.buildProject( projectId );
326     }
327 
328     public int buildProject( int projectId, int buildDefinitionId )
329         throws Exception
330     {
331         return continuum.buildProject( projectId, buildDefinitionId );
332     }
333 
334     public int buildProject( int projectId, BuildTrigger buildTrigger )
335         throws Exception
336     {
337         return continuum.buildProject( projectId, buildTrigger );
338     }
339 
340     public int buildProject( int projectId, int buildDefinitionId, BuildTrigger buildTrigger )
341         throws Exception
342     {
343         return continuum.buildProject( projectId, buildDefinitionId, buildTrigger );
344     }
345 
346     public int buildGroup( int projectGroupId )
347         throws Exception
348     {
349         return continuum.buildGroup( projectGroupId );
350     }
351 
352     public int buildGroup( int projectGroupId, int buildDefinitionId )
353         throws Exception
354     {
355         return continuum.buildGroup( projectGroupId, buildDefinitionId );
356     }
357 
358     // ----------------------------------------------------------------------
359     // SCM roots
360     // ----------------------------------------------------------------------
361 
362     public List<ProjectScmRoot> getProjectScmRootByProjectGroup( int projectGroupId )
363         throws Exception
364     {
365         return continuum.getProjectScmRootByProjectGroup( projectGroupId );
366     }
367 
368     public ProjectScmRoot getProjectScmRootByProject( int projectId )
369         throws Exception
370     {
371         return continuum.getProjectScmRootByProject( projectId );
372     }
373 
374     // ----------------------------------------------------------------------
375     // Build Results
376     // ----------------------------------------------------------------------
377 
378     public BuildResult getLatestBuildResult( int projectId )
379         throws Exception
380     {
381         return continuum.getLatestBuildResult( projectId );
382     }
383 
384     public BuildResult getBuildResult( int projectId, int buildId )
385         throws Exception
386     {
387         return continuum.getBuildResult( projectId, buildId );
388     }
389 
390     public List<BuildResultSummary> getBuildResultsForProject( int projectId )
391         throws Exception
392     {
393         return continuum.getBuildResultsForProject( projectId );
394     }
395 
396     public int removeBuildResult( BuildResult br )
397         throws Exception
398     {
399         return continuum.removeBuildResult( br );
400     }
401 
402     public String getBuildOutput( int projectId, int buildId )
403         throws Exception
404     {
405         return continuum.getBuildOutput( projectId, buildId );
406     }
407 
408     // ----------------------------------------------------------------------
409     // Maven 2.x projects
410     // ----------------------------------------------------------------------
411 
412     public AddingResult addMavenTwoProject( String url )
413         throws Exception
414     {
415         return continuum.addMavenTwoProject( url );
416     }
417 
418     public AddingResult addMavenTwoProject( String url, int projectGroupId )
419         throws Exception
420     {
421         return continuum.addMavenTwoProject( url, projectGroupId );
422     }
423 
424     public AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkoutInSingleDirectory )
425         throws Exception
426     {
427         return continuum.addMavenTwoProject( url, projectGroupId, checkoutInSingleDirectory );
428     }
429 
430     public AddingResult addMavenTwoProjectAsSingleProject( String url, int projectGroupId )
431         throws Exception
432     {
433         return continuum.addMavenTwoProjectAsSingleProject( url, projectGroupId );
434     }
435 
436     public AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkProtocol,
437                                             boolean useCredentialsCache, boolean recursiveProjects,
438                                             boolean checkoutInSingleDirectory )
439         throws Exception
440     {
441         return continuum.addMavenTwoProject( url, projectGroupId, checkProtocol, useCredentialsCache, recursiveProjects,
442                                              checkoutInSingleDirectory );
443     }
444 
445     // ----------------------------------------------------------------------
446     // Maven 1.x projects
447     // ----------------------------------------------------------------------
448 
449     public AddingResult addMavenOneProject( String url, int projectGroupId )
450         throws Exception
451     {
452         return continuum.addMavenOneProject( url, projectGroupId );
453     }
454 
455     // ----------------------------------------------------------------------
456     // Maven ANT projects
457     // ----------------------------------------------------------------------
458 
459     public ProjectSummary addAntProject( ProjectSummary project, int projectGroupId )
460         throws Exception
461     {
462         return continuum.addAntProject( project, projectGroupId );
463     }
464 
465     // ----------------------------------------------------------------------
466     // Maven Shell projects
467     // ----------------------------------------------------------------------
468 
469     public ProjectSummary addShellProject( ProjectSummary project, int projectGroupId )
470         throws Exception
471     {
472         return continuum.addShellProject( project, projectGroupId );
473     }
474 
475     // ----------------------------------------------------------------------
476     // Schedules
477     // ----------------------------------------------------------------------
478 
479     public List<Schedule> getSchedules()
480         throws Exception
481     {
482         return continuum.getSchedules();
483     }
484 
485     public Schedule getSchedule( int scheduleId )
486         throws Exception
487     {
488         return continuum.getSchedule( scheduleId );
489     }
490 
491     public Schedule addSchedule( Schedule schedule )
492         throws Exception
493     {
494         return continuum.addSchedule( schedule );
495     }
496 
497     public Schedule updateSchedule( Schedule schedule )
498         throws Exception
499     {
500         return continuum.updateSchedule( schedule );
501     }
502 
503     // ----------------------------------------------------------------------
504     // Profiles
505     // ----------------------------------------------------------------------
506 
507     public List<Profile> getProfiles()
508         throws Exception
509     {
510         return continuum.getProfiles();
511     }
512 
513     public Profile getProfile( int profileId )
514         throws Exception
515     {
516         return continuum.getProfile( profileId );
517     }
518 
519     public Profile getProfileWithName( String profileName )
520         throws Exception
521     {
522         return continuum.getProfileWithName( profileName );
523     }
524 
525     // ----------------------------------------------------------------------
526     // Installations
527     // ----------------------------------------------------------------------
528 
529     public List<Installation> getInstallations()
530         throws Exception
531     {
532         return continuum.getInstallations();
533     }
534 
535     public Installation getInstallation( int installationId )
536         throws Exception
537     {
538         return continuum.getInstallation( installationId );
539     }
540 
541     public Installation getInstallation( String installationName )
542         throws Exception
543     {
544         return continuum.getInstallation( installationName );
545     }
546 
547     public List<Installation> getBuildAgentInstallations( String url )
548         throws Exception
549     {
550         return continuum.getBuildAgentInstallations( url );
551     }
552 
553     // ----------------------------------------------------------------------
554     // SystemConfiguration
555     // ----------------------------------------------------------------------
556 
557     public SystemConfiguration getSystemConfiguration()
558         throws Exception
559     {
560         return continuum.getSystemConfiguration();
561     }
562 
563     // ----------------------------------------------------------------------
564     // Utils
565     // ----------------------------------------------------------------------
566 
567     public String getProjectStatusAsString( int status )
568     {
569         return statusMap.get( new Integer( status ) );
570     }
571 
572     // ----------------------------------------------------------------------
573     // Queue
574     // ----------------------------------------------------------------------
575     public boolean isProjectInPrepareBuildQueue( int projectId )
576         throws Exception
577     {
578         return continuum.isProjectInPrepareBuildQueue( projectId );
579     }
580 
581     public boolean isProjectInPrepareBuildQueue( int projectId, int buildDefinitionId )
582         throws Exception
583     {
584         return continuum.isProjectInPrepareBuildQueue( projectId, buildDefinitionId );
585     }
586 
587     public List<BuildProjectTask> getProjectsInBuildQueue()
588         throws Exception
589     {
590         return continuum.getProjectsInBuildQueue();
591     }
592 
593     public boolean isProjectInBuildingQueue( int projectId )
594         throws Exception
595     {
596         return continuum.isProjectInBuildingQueue( projectId );
597     }
598 
599     public boolean isProjectInBuildingQueue( int projectId, int buildDefinitionId )
600         throws Exception
601     {
602         return continuum.isProjectInBuildingQueue( projectId, buildDefinitionId );
603     }
604 
605     public boolean isProjectCurrentlyPreparingBuild( int projectId )
606         throws Exception
607     {
608         return continuum.isProjectCurrentlyPreparingBuild( projectId );
609     }
610 
611     public boolean isProjectCurrentlyPreparingBuild( int projectId, int buildDefinitionId )
612         throws Exception
613     {
614         return continuum.isProjectCurrentlyPreparingBuild( projectId, buildDefinitionId );
615     }
616 
617     public boolean isProjectCurrentlyBuilding( int projectId )
618         throws Exception
619     {
620         return continuum.isProjectCurrentlyBuilding( projectId );
621     }
622 
623     public boolean isProjectCurrentlyBuilding( int projectId, int buildDefinitionId )
624         throws Exception
625     {
626         return continuum.isProjectCurrentlyBuilding( projectId, buildDefinitionId );
627     }
628 
629     public int removeProjectsFromBuildingQueue( int[] projectsId )
630         throws Exception
631     {
632         return continuum.removeProjectsFromBuildingQueue( projectsId );
633     }
634 
635     public boolean cancelCurrentBuild()
636         throws Exception
637     {
638         return continuum.cancelCurrentBuild();
639     }
640 
641     public boolean cancelBuild( int projectId, int buildDefinitionId )
642         throws Exception
643     {
644         return continuum.cancelBuild( projectId, buildDefinitionId );
645     }
646 
647     // ----------------------------------------------------------------------
648     // Release Result
649     // ----------------------------------------------------------------------
650 
651     public ContinuumReleaseResult getReleaseResult( int releaseId )
652         throws Exception
653     {
654         return continuum.getReleaseResult( releaseId );
655     }
656 
657     public List<ContinuumReleaseResult> getReleaseResultsForProjectGroup( int projectGroupId )
658         throws Exception
659     {
660         return continuum.getReleaseResultsForProjectGroup( projectGroupId );
661     }
662 
663     public int removeReleaseResult( ContinuumReleaseResult releaseResult )
664         throws Exception
665     {
666         return continuum.removeReleaseResult( releaseResult );
667     }
668 
669     public String getReleaseOutput( int releaseId )
670         throws Exception
671     {
672         return continuum.getReleaseOutput( releaseId );
673     }
674 
675     // ----------------------------------------------------------------------
676     // Purge Configuration
677     // ----------------------------------------------------------------------
678 
679     public RepositoryPurgeConfiguration addRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
680         throws Exception
681     {
682         return continuum.addRepositoryPurgeConfiguration( repoPurge );
683     }
684 
685     public int updateRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
686         throws Exception
687     {
688         return continuum.updateRepositoryPurgeConfiguration( repoPurge );
689     }
690 
691     public int removeRepositoryPurgeConfiguration( int repoPurgeId )
692         throws Exception
693     {
694         return continuum.removeRepositoryPurgeConfiguration( repoPurgeId );
695     }
696 
697     public RepositoryPurgeConfiguration getRepositoryPurgeConfiguration( int repoPurgeId )
698         throws Exception
699     {
700         return continuum.getRepositoryPurgeConfiguration( repoPurgeId );
701     }
702 
703     public List<RepositoryPurgeConfiguration> getAllRepositoryPurgeConfigurations()
704         throws Exception
705     {
706         return continuum.getAllRepositoryPurgeConfigurations();
707     }
708 
709     public DirectoryPurgeConfiguration addDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
710         throws Exception
711     {
712         return continuum.addDirectoryPurgeConfiguration( dirPurge );
713     }
714 
715     public int updateDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
716         throws Exception
717     {
718         return continuum.updateDirectoryPurgeConfiguration( dirPurge );
719     }
720 
721     public int removeDirectoryPurgeConfiguration( int dirPurgeId )
722         throws Exception
723     {
724         return continuum.removeDirectoryPurgeConfiguration( dirPurgeId );
725     }
726 
727     public DirectoryPurgeConfiguration getDirectoryPurgeConfiguration( int dirPurgeId )
728         throws Exception
729     {
730         return continuum.getDirectoryPurgeConfiguration( dirPurgeId );
731     }
732 
733     public List<DirectoryPurgeConfiguration> getAllDirectoryPurgeConfigurations()
734         throws Exception
735     {
736         return continuum.getAllDirectoryPurgeConfigurations();
737     }
738 
739     public int purgeLocalRepository( int repoPurgeId )
740         throws Exception
741     {
742         return continuum.purgeLocalRepository( repoPurgeId );
743     }
744 
745     public int purgeDirectory( int dirPurgeId )
746         throws Exception
747     {
748         return continuum.purgeDirectory( dirPurgeId );
749     }
750 
751     // ----------------------------------------------------------------------
752     // Local Repository
753     // ----------------------------------------------------------------------
754 
755     public LocalRepository addLocalRepository( LocalRepository repository )
756         throws Exception
757     {
758         return continuum.addLocalRepository( repository );
759     }
760 
761     public int updateLocalRepository( LocalRepository repository )
762         throws Exception
763     {
764         return continuum.updateLocalRepository( repository );
765     }
766 
767     public int removeLocalRepository( int repositoryId )
768         throws Exception
769     {
770         return continuum.removeLocalRepository( repositoryId );
771     }
772 
773     public LocalRepository getLocalRepository( int repositoryId )
774         throws Exception
775     {
776         return continuum.getLocalRepository( repositoryId );
777     }
778 
779     public List<LocalRepository> getAllLocalRepositories()
780         throws Exception
781     {
782         return continuum.getAllLocalRepositories();
783     }
784 
785     // ----------------------------------------------------------------------
786     // ConfigurationService
787     // ----------------------------------------------------------------------
788 
789     public BuildAgentConfiguration addBuildAgent( BuildAgentConfiguration buildAgentConfiguration )
790         throws Exception
791     {
792         return continuum.addBuildAgent( buildAgentConfiguration );
793     }
794 
795     public BuildAgentConfiguration getBuildAgent( String url )
796 
797     {
798         return continuum.getBuildAgent( url );
799     }
800 
801     public BuildAgentConfiguration updateBuildAgent( BuildAgentConfiguration buildAgentConfiguration )
802         throws Exception
803 
804     {
805         return continuum.updateBuildAgent( buildAgentConfiguration );
806     }
807 
808     public boolean removeBuildAgent( String url )
809         throws Exception
810 
811     {
812         return continuum.removeBuildAgent( url );
813     }
814 
815     public List<BuildAgentConfiguration> getAllBuildAgents()
816     {
817         return continuum.getAllBuildAgents();
818     }
819 
820     public Map<String, Object> addAntProjectRPC( Map<String, Object> project, int projectGroupId )
821         throws Exception
822     {
823         return continuum.addAntProjectRPC( project, projectGroupId );
824     }
825 
826     public Map<String, Object> addBuildDefinitionToProjectGroupRPC( int projectGroupId, Map<String, Object> buildDef )
827         throws Exception
828     {
829         return continuum.addBuildDefinitionToProjectGroupRPC( projectGroupId, buildDef );
830     }
831 
832     public Map<String, Object> addBuildDefinitionToProjectRPC( int projectId, Map<String, Object> buildDef )
833         throws Exception
834     {
835         return continuum.addBuildDefinitionToProjectRPC( projectId, buildDef );
836     }
837 
838     public Map<String, Object> addMavenOneProjectRPC( String url, int projectGroupId )
839         throws Exception
840     {
841         return continuum.addMavenOneProjectRPC( url, projectGroupId );
842     }
843 
844     public Map<String, Object> addMavenTwoProjectRPC( String url )
845         throws Exception
846     {
847         return continuum.addMavenTwoProjectRPC( url );
848     }
849 
850     public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId )
851         throws Exception
852     {
853         return continuum.addMavenTwoProjectRPC( url, projectGroupId );
854     }
855 
856     public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId,
857                                                       boolean checkoutInSingleDirectory )
858         throws Exception
859     {
860         return continuum.addMavenTwoProjectRPC( url, projectGroupId, checkoutInSingleDirectory );
861     }
862 
863     public Map<String, Object> addMavenTwoProjectAsSingleProjectRPC( String url, int projectGroupId )
864         throws Exception
865     {
866         return continuum.addMavenTwoProjectAsSingleProjectRPC( url, projectGroupId );
867     }
868 
869     public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId, boolean checkProtocol,
870                                                       boolean useCredentialsCache, boolean recursiveProjects,
871                                                       boolean checkoutInSingleDirectory )
872         throws Exception
873     {
874         return continuum.addMavenTwoProjectRPC( url, projectGroupId, checkProtocol, useCredentialsCache,
875                                                 recursiveProjects, checkoutInSingleDirectory );
876     }
877 
878     public Map<String, Object> addProjectGroupRPC( String groupName, String groupId, String description )
879         throws Exception
880     {
881         return continuum.addProjectGroupRPC( groupName, groupId, description );
882     }
883 
884     public Map<String, Object> addScheduleRPC( Map<String, Object> schedule )
885         throws Exception
886     {
887         return continuum.addScheduleRPC( schedule );
888     }
889 
890     public Map<String, Object> addShellProjectRPC( Map<String, Object> project, int projectGroupId )
891         throws Exception
892     {
893         return continuum.addShellProjectRPC( project, projectGroupId );
894     }
895 
896     public List<Object> getAllProjectGroupsRPC()
897         throws Exception
898     {
899         return continuum.getAllProjectGroupsRPC();
900     }
901 
902     public List<Object> getAllProjectGroupsWithAllDetailsRPC()
903         throws Exception
904     {
905         return continuum.getAllProjectGroupsWithAllDetailsRPC();
906     }
907 
908     public List<Object> getBuildDefinitionTemplatesRPC()
909         throws Exception
910     {
911         return continuum.getBuildDefinitionTemplatesRPC();
912     }
913 
914     public List<Object> getBuildDefinitionsForProjectGroupRPC( int projectGroupId )
915         throws Exception
916     {
917         return continuum.getBuildDefinitionsForProjectGroupRPC( projectGroupId );
918     }
919 
920     public List<Object> getBuildDefinitionsForProjectRPC( int projectId )
921         throws Exception
922     {
923         return continuum.getBuildDefinitionsForProjectRPC( projectId );
924     }
925 
926     public Map<String, Object> getBuildResultRPC( int projectId, int buildId )
927         throws Exception
928     {
929         return continuum.getBuildResultRPC( projectId, buildId );
930     }
931 
932     public List<Object> getBuildResultsForProjectRPC( int projectId )
933         throws Exception
934     {
935         return continuum.getBuildResultsForProjectRPC( projectId );
936     }
937 
938     public Map<String, Object> getInstallationRPC( int installationId )
939         throws Exception
940     {
941         return continuum.getInstallationRPC( installationId );
942     }
943 
944     public Map<String, Object> getInstallationRPC( String installationName )
945         throws Exception
946     {
947         return continuum.getInstallationRPC( installationName );
948     }
949 
950     public List<Object> getInstallationsRPC()
951         throws Exception
952     {
953         return continuum.getInstallationsRPC();
954     }
955 
956     public List<Object> getBuildAgentInstallationsRPC( String url )
957         throws Exception
958     {
959         return continuum.getBuildAgentInstallationsRPC( url );
960     }
961 
962     public Map<String, Object> getLatestBuildResultRPC( int projectId )
963         throws Exception
964     {
965         return continuum.getLatestBuildResultRPC( projectId );
966     }
967 
968     public Map<String, Object> getProfileRPC( int profileId )
969         throws Exception
970     {
971         return continuum.getProfileRPC( profileId );
972     }
973 
974     public Map<String, Object> getProfileWithNameRPC( String profileName )
975         throws Exception
976     {
977         return continuum.getProfileWithNameRPC( profileName );
978     }
979 
980     public List<Object> getProfilesRPC()
981         throws Exception
982     {
983         return continuum.getProfilesRPC();
984     }
985 
986     public Map<String, Object> getProjectGroupSummaryRPC( int projectGroupId )
987         throws Exception
988     {
989         return continuum.getProjectGroupSummaryRPC( projectGroupId );
990     }
991 
992     public Map<String, Object> getProjectGroupWithProjectsRPC( int projectGroupId )
993         throws Exception
994     {
995         return continuum.getProjectGroupWithProjectsRPC( projectGroupId );
996     }
997 
998     public Map<String, Object> updateProjectGroupRPC( Map<String, Object> projectGroup )
999         throws Exception
1000     {
1001         return continuum.updateProjectGroupRPC( projectGroup );
1002     }
1003 
1004     public Map<String, Object> getProjectSummaryRPC( int projectId )
1005         throws Exception
1006     {
1007         return continuum.getProjectSummaryRPC( projectId );
1008     }
1009 
1010     public Map<String, Object> getProjectWithAllDetailsRPC( int projectId )
1011         throws Exception
1012     {
1013         return continuum.getProjectWithAllDetailsRPC( projectId );
1014     }
1015 
1016     public List<Object> getProjectsRPC( int projectGroupId )
1017         throws Exception
1018     {
1019         return continuum.getProjectsRPC( projectGroupId );
1020     }
1021 
1022     public Map<String, Object> getScheduleRPC( int scheduleId )
1023         throws Exception
1024     {
1025         return continuum.getScheduleRPC( scheduleId );
1026     }
1027 
1028     public List<Object> getSchedulesRPC()
1029         throws Exception
1030     {
1031         return continuum.getSchedulesRPC();
1032     }
1033 
1034     public Map<String, Object> getSystemConfigurationRPC()
1035         throws Exception
1036     {
1037         return continuum.getSystemConfigurationRPC();
1038     }
1039 
1040     public int removeBuildResultRPC( Map<String, Object> br )
1041         throws Exception
1042     {
1043         return continuum.removeBuildResultRPC( br );
1044     }
1045 
1046     public Map<String, Object> updateBuildDefinitionForProjectGroupRPC( int projectGroupId,
1047                                                                         Map<String, Object> buildDef )
1048         throws Exception
1049     {
1050         return continuum.updateBuildDefinitionForProjectGroupRPC( projectGroupId, buildDef );
1051     }
1052 
1053     public Map<String, Object> updateBuildDefinitionForProjectRPC( int projectId, Map<String, Object> buildDef )
1054         throws Exception
1055     {
1056         return continuum.updateBuildDefinitionForProjectRPC( projectId, buildDef );
1057     }
1058 
1059     public Map<String, Object> updateProjectRPC( Map<String, Object> project )
1060         throws Exception
1061     {
1062         return continuum.updateProjectRPC( project );
1063     }
1064 
1065     public Map<String, Object> updateScheduleRPC( Map<String, Object> schedule )
1066         throws Exception
1067     {
1068         return continuum.updateScheduleRPC( schedule );
1069     }
1070 
1071     public ProjectGroup getProjectGroup( int projectGroupId )
1072         throws Exception
1073     {
1074         return continuum.getProjectGroup( projectGroupId );
1075     }
1076 
1077     public Map<String, Object> getProjectGroupRPC( int projectGroupId )
1078         throws Exception
1079     {
1080         return continuum.getProjectGroupRPC( projectGroupId );
1081     }
1082 
1083     public ProjectNotifier getGroupNotifier( int projectgroupid, int notifierId )
1084         throws Exception
1085     {
1086         return continuum.getGroupNotifier( projectgroupid, notifierId );
1087     }
1088 
1089     public Map<String, Object> getGroupNotifierRPC( int projectgroupid, int notifierId )
1090         throws Exception
1091     {
1092         return continuum.getGroupNotifierRPC( projectgroupid, notifierId );
1093     }
1094 
1095     public ProjectNotifier getNotifier( int projectid, int notifierId )
1096         throws Exception
1097     {
1098         return continuum.getNotifier( projectid, notifierId );
1099     }
1100 
1101     public Map<String, Object> getNotifierRPC( int projectid, int notifierId )
1102         throws Exception
1103     {
1104         return continuum.getNotifierRPC( projectid, notifierId );
1105     }
1106 
1107     public ProjectNotifier updateGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
1108         throws Exception
1109     {
1110         return continuum.updateGroupNotifier( projectgroupid, newNotifier );
1111     }
1112 
1113     public Map<String, Object> updateGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
1114         throws Exception
1115     {
1116         return continuum.updateGroupNotifierRPC( projectgroupid, newNotifier );
1117     }
1118 
1119     public ProjectNotifier updateNotifier( int projectid, ProjectNotifier newNotifier )
1120         throws Exception
1121     {
1122         return continuum.updateNotifier( projectid, newNotifier );
1123     }
1124 
1125     public Map<String, Object> updateNotifierRPC( int projectid, Map<String, Object> newNotifier )
1126         throws Exception
1127     {
1128         return continuum.updateNotifierRPC( projectid, newNotifier );
1129     }
1130 
1131     public int removeGroupNotifier( int projectgroupid, int notifierId )
1132         throws Exception
1133     {
1134         return continuum.removeGroupNotifier( projectgroupid, notifierId );
1135     }
1136 
1137     public int removeNotifier( int projectid, int notifierId )
1138         throws Exception
1139     {
1140         return continuum.removeNotifier( projectid, notifierId );
1141     }
1142 
1143     public ProjectNotifier addGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
1144         throws Exception
1145     {
1146         return continuum.addGroupNotifier( projectgroupid, newNotifier );
1147     }
1148 
1149     public Map<String, Object> addGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
1150         throws Exception
1151     {
1152         return continuum.addGroupNotifierRPC( projectgroupid, newNotifier );
1153     }
1154 
1155     public ProjectNotifier addNotifier( int projectid, ProjectNotifier newNotifier )
1156         throws Exception
1157     {
1158         return continuum.addNotifier( projectid, newNotifier );
1159     }
1160 
1161     public Map<String, Object> addNotifierRPC( int projectid, Map<String, Object> newNotifier )
1162         throws Exception
1163     {
1164         return continuum.addNotifierRPC( projectid, newNotifier );
1165     }
1166 
1167     public Installation addInstallation( Installation installation )
1168         throws Exception
1169     {
1170         return continuum.addInstallation( installation );
1171     }
1172 
1173     public Map<String, Object> addInstallationRPC( Map<String, Object> installation )
1174         throws Exception
1175     {
1176         return continuum.addInstallationRPC( installation );
1177     }
1178 
1179     public Profile addProfile( Profile profile )
1180         throws Exception
1181     {
1182         return continuum.addProfile( profile );
1183     }
1184 
1185     public Map<String, Object> addProfileRPC( Map<String, Object> profile )
1186         throws Exception
1187     {
1188         return continuum.addProfileRPC( profile );
1189     }
1190 
1191     public int deleteInstallation( int installationId )
1192         throws Exception
1193     {
1194         return continuum.deleteInstallation( installationId );
1195     }
1196 
1197     public int deleteProfile( int profileId )
1198         throws Exception
1199     {
1200         return continuum.deleteProfile( profileId );
1201     }
1202 
1203     public int updateInstallation( Installation installation )
1204         throws Exception
1205     {
1206         return continuum.updateInstallation( installation );
1207     }
1208 
1209     public int updateInstallationRPC( Map<String, Object> installation )
1210         throws Exception
1211     {
1212         return continuum.updateInstallationRPC( installation );
1213     }
1214 
1215     public int updateProfile( Profile profile )
1216         throws Exception
1217     {
1218         return continuum.updateProfile( profile );
1219     }
1220 
1221     public int updateProfileRPC( Map<String, Object> profile )
1222         throws Exception
1223     {
1224         return continuum.updateProfileRPC( profile );
1225     }
1226 
1227     public Map<String, Object> getReleaseResultRPC( int releaseId )
1228         throws Exception
1229     {
1230         return continuum.getReleaseResultRPC( releaseId );
1231     }
1232 
1233     public List<Object> getReleaseResultsForProjectGroupRPC( int projectGroupId )
1234         throws Exception
1235     {
1236         return continuum.getReleaseResultsForProjectGroupRPC( projectGroupId );
1237     }
1238 
1239     public int removeReleaseResultRPC( Map<String, Object> rr )
1240         throws Exception
1241     {
1242         return continuum.removeReleaseResultRPC( rr );
1243     }
1244 
1245     public Map<String, Object> addRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
1246         throws Exception
1247     {
1248         return continuum.addRepositoryPurgeConfigurationRPC( repoPurge );
1249     }
1250 
1251     public int updateRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
1252         throws Exception
1253     {
1254         return continuum.updateRepositoryPurgeConfigurationRPC( repoPurge );
1255     }
1256 
1257     public Map<String, Object> getRepositoryPurgeConfigurationRPC( int repoPurgeId )
1258         throws Exception
1259     {
1260         return continuum.getRepositoryPurgeConfigurationRPC( repoPurgeId );
1261     }
1262 
1263     public List<Object> getAllRepositoryPurgeConfigurationsRPC()
1264         throws Exception
1265     {
1266         return continuum.getAllRepositoryPurgeConfigurationsRPC();
1267     }
1268 
1269     public Map<String, Object> addDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
1270         throws Exception
1271     {
1272         return continuum.addDirectoryPurgeConfigurationRPC( dirPurge );
1273     }
1274 
1275     public int updateDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
1276         throws Exception
1277     {
1278         return continuum.updateDirectoryPurgeConfigurationRPC( dirPurge );
1279     }
1280 
1281     public Map<String, Object> getDirectoryPurgeConfigurationRPC( int dirPurgeId )
1282         throws Exception
1283     {
1284         return continuum.getDirectoryPurgeConfigurationRPC( dirPurgeId );
1285     }
1286 
1287     public List<Object> getAllDirectoryPurgeConfigurationsRPC()
1288         throws Exception
1289     {
1290         return continuum.getAllDirectoryPurgeConfigurationsRPC();
1291     }
1292 
1293     public Map<String, Object> addLocalRepositoryRPC( Map<String, Object> repository )
1294         throws Exception
1295     {
1296         return continuum.addLocalRepositoryRPC( repository );
1297     }
1298 
1299     public int updateLocalRepositoryRPC( Map<String, Object> repository )
1300         throws Exception
1301     {
1302         return continuum.updateLocalRepositoryRPC( repository );
1303     }
1304 
1305     public Map<String, Object> getLocalRepositoryRPC( int repositoryId )
1306         throws Exception
1307     {
1308         return continuum.getLocalRepositoryRPC( repositoryId );
1309     }
1310 
1311     public List<Object> getAllLocalRepositoriesRPC()
1312         throws Exception
1313     {
1314         return continuum.getAllLocalRepositoriesRPC();
1315     }
1316 
1317     public Map<String, Object> addBuildAgentRPC( Map<String, Object> buildAgentConfiguration )
1318         throws Exception
1319     {
1320         return continuum.addBuildAgentRPC( buildAgentConfiguration );
1321     }
1322 
1323     public Map<String, Object> getBuildAgentRPC( String url )
1324 
1325     {
1326         return continuum.getBuildAgentRPC( url );
1327     }
1328 
1329     public Map<String, Object> updateBuildAgentRPC( Map<String, Object> buildAgentConfiguration )
1330         throws Exception
1331 
1332     {
1333         return continuum.updateBuildAgentRPC( buildAgentConfiguration );
1334     }
1335 
1336     public List<Object> getAllBuildAgentsRPC()
1337     {
1338         return continuum.getAllBuildAgentsRPC();
1339     }
1340 
1341     public int releasePerform( int projectId, String releaseId, String goals, String arguments,
1342                                boolean useReleaseProfile, String repositoryName, String username )
1343         throws Exception
1344     {
1345         return continuum.releasePerform( projectId, releaseId, goals, arguments, useReleaseProfile, repositoryName,
1346                                          username );
1347     }
1348 
1349     public String releasePrepare( int projectId, Properties releaseProperties, Map<String, String> releaseVersions,
1350                                   Map<String, String> developmentVersions, Map<String, String> environments,
1351                                   String username )
1352         throws Exception
1353     {
1354         return continuum.releasePrepare( projectId, releaseProperties, releaseVersions, developmentVersions,
1355                                          environments, username );
1356     }
1357 
1358     public ReleaseListenerSummary getListener( int projectId, String releaseId )
1359         throws Exception
1360     {
1361         return continuum.getListener( projectId, releaseId );
1362     }
1363 
1364     public int releaseCleanup( int projectId, String releaseId )
1365         throws Exception
1366     {
1367         return continuum.releaseCleanup( projectId, releaseId );
1368     }
1369 
1370     public int releaseCleanup( int projectId, String releaseId, String releaseType )
1371         throws Exception
1372     {
1373         return continuum.releaseCleanup( projectId, releaseId, releaseType );
1374     }
1375 
1376     public int releaseRollback( int projectId, String releaseId )
1377         throws Exception
1378     {
1379         return continuum.releaseRollback( projectId, releaseId );
1380     }
1381 
1382     public Map<String, Object> getReleasePluginParameters( int projectId )
1383         throws Exception
1384     {
1385         return continuum.getReleasePluginParameters( projectId );
1386     }
1387 
1388     public List<Map<String, String>> getProjectReleaseAndDevelopmentVersions( int projectId, String pomFilename,
1389                                                                               boolean autoVersionSubmodules )
1390         throws Exception
1391     {
1392         return continuum.getProjectReleaseAndDevelopmentVersions( projectId, pomFilename, autoVersionSubmodules );
1393     }
1394 
1395     public boolean pingBuildAgent( String buildAgentUrl )
1396         throws Exception
1397     {
1398         return continuum.pingBuildAgent( buildAgentUrl );
1399     }
1400 
1401     public String getBuildAgentUrl( int projectId, int buildDefinitionId )
1402         throws Exception
1403     {
1404         return continuum.getBuildAgentUrl( projectId, buildDefinitionId );
1405     }
1406 
1407     public BuildDefinition getBuildDefinition( int buildDefinitionId )
1408         throws Exception
1409     {
1410         return continuum.getBuildDefinition( buildDefinitionId );
1411     }
1412 
1413     public Map<String, Object> getBuildDefinitionRPC( int buildDefinitionId )
1414         throws Exception
1415     {
1416         return continuum.getBuildDefinitionRPC( buildDefinitionId );
1417     }
1418 
1419     public BuildAgentGroupConfiguration addBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup )
1420         throws Exception
1421     {
1422         return continuum.addBuildAgentGroup( buildAgentGroup );
1423     }
1424 
1425     public Map<String, Object> addBuildAgentGroupRPC( Map<String, Object> buildAgentGroup )
1426         throws Exception
1427     {
1428         return continuum.addBuildAgentGroupRPC( buildAgentGroup );
1429     }
1430 
1431     public BuildAgentGroupConfiguration getBuildAgentGroup( String name )
1432     {
1433         return continuum.getBuildAgentGroup( name );
1434     }
1435 
1436     public Map<String, Object> getBuildAgentGroupRPC( String name )
1437     {
1438         return continuum.getBuildAgentGroupRPC( name );
1439     }
1440 
1441     public BuildAgentGroupConfiguration updateBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup )
1442         throws Exception
1443     {
1444         return continuum.updateBuildAgentGroup( buildAgentGroup );
1445     }
1446 
1447     public Map<String, Object> updateBuildAgentGroupRPC( Map<String, Object> buildAgentGroup )
1448         throws Exception
1449     {
1450         return continuum.updateBuildAgentGroupRPC( buildAgentGroup );
1451     }
1452 
1453     public int removeBuildAgentGroup( String name )
1454         throws Exception
1455     {
1456         return continuum.removeBuildAgentGroup( name );
1457     }
1458 
1459     public List<BuildAgentConfiguration> getBuildAgentsWithInstallations()
1460         throws Exception
1461     {
1462         return continuum.getBuildAgentsWithInstallations();
1463     }
1464 
1465     public List<Object> getBuildAgentsWithInstallationsRPC()
1466         throws Exception
1467     {
1468         return continuum.getBuildAgentsWithInstallationsRPC();
1469     }
1470 }