1 package org.apache.maven.continuum.xmlrpc.client;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
61
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
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
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
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
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
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
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
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
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
447
448
449 public AddingResult addMavenOneProject( String url, int projectGroupId )
450 throws Exception
451 {
452 return continuum.addMavenOneProject( url, projectGroupId );
453 }
454
455
456
457
458
459 public ProjectSummary addAntProject( ProjectSummary project, int projectGroupId )
460 throws Exception
461 {
462 return continuum.addAntProject( project, projectGroupId );
463 }
464
465
466
467
468
469 public ProjectSummary addShellProject( ProjectSummary project, int projectGroupId )
470 throws Exception
471 {
472 return continuum.addShellProject( project, projectGroupId );
473 }
474
475
476
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
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
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
555
556
557 public SystemConfiguration getSystemConfiguration()
558 throws Exception
559 {
560 return continuum.getSystemConfiguration();
561 }
562
563
564
565
566
567 public String getProjectStatusAsString( int status )
568 {
569 return statusMap.get( new Integer( status ) );
570 }
571
572
573
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
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
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
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
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 }