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 java.net.URL;
23 import java.util.Hashtable;
24 import java.util.List;
25 import java.util.Map;
26
27 import org.apache.continuum.xmlrpc.release.ContinuumReleaseResult;
28 import org.apache.continuum.xmlrpc.repository.DirectoryPurgeConfiguration;
29 import org.apache.continuum.xmlrpc.repository.LocalRepository;
30 import org.apache.continuum.xmlrpc.repository.RepositoryPurgeConfiguration;
31 import org.apache.maven.continuum.xmlrpc.ContinuumService;
32 import org.apache.maven.continuum.xmlrpc.project.AddingResult;
33 import org.apache.maven.continuum.xmlrpc.project.BuildDefinition;
34 import org.apache.maven.continuum.xmlrpc.project.BuildDefinitionTemplate;
35 import org.apache.maven.continuum.xmlrpc.project.BuildProjectTask;
36 import org.apache.maven.continuum.xmlrpc.project.BuildResult;
37 import org.apache.maven.continuum.xmlrpc.project.BuildResultSummary;
38 import org.apache.maven.continuum.xmlrpc.project.ContinuumProjectState;
39 import org.apache.maven.continuum.xmlrpc.project.Project;
40 import org.apache.maven.continuum.xmlrpc.project.ProjectGroup;
41 import org.apache.maven.continuum.xmlrpc.project.ProjectGroupSummary;
42 import org.apache.maven.continuum.xmlrpc.project.ProjectNotifier;
43 import org.apache.maven.continuum.xmlrpc.project.ProjectSummary;
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.util.ClientFactory;
51
52
53
54
55
56 public class ContinuumXmlRpcClient
57 implements ContinuumService
58 {
59 private final ContinuumService continuum;
60
61 private static Hashtable<Integer, String> statusMap;
62
63 static
64 {
65 statusMap = new Hashtable<Integer, String>();
66 statusMap.put( ContinuumProjectState.NEW, "New" );
67 statusMap.put( ContinuumProjectState.CHECKEDOUT, "New" );
68 statusMap.put( ContinuumProjectState.OK, "OK" );
69 statusMap.put( ContinuumProjectState.FAILED, "Failed" );
70 statusMap.put( ContinuumProjectState.ERROR, "Error" );
71 statusMap.put( ContinuumProjectState.BUILDING, "Building" );
72 statusMap.put( ContinuumProjectState.CHECKING_OUT, "Checking out" );
73 statusMap.put( ContinuumProjectState.UPDATING, "Updating" );
74 statusMap.put( ContinuumProjectState.WARNING, "Warning" );
75 }
76
77 public ContinuumXmlRpcClient( URL serviceUrl )
78 {
79 this( serviceUrl, null, null );
80 }
81
82 public ContinuumXmlRpcClient( URL serviceUrl, String login, String password )
83 {
84 XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl()
85 {
86 public boolean isEnabledForExtensions()
87 {
88 return true;
89 }
90 };
91
92 if ( login != null )
93 {
94 config.setBasicUserName( login );
95 config.setBasicPassword( password );
96 }
97 config.setServerURL( serviceUrl );
98
99 XmlRpcClient client = new XmlRpcClient();
100 client.setConfig( config );
101 ClientFactory factory = new ClientFactory( client );
102 continuum = (ContinuumService) factory.newInstance( ContinuumService.class );
103 }
104
105 public boolean ping()
106 throws Exception
107 {
108 return continuum.ping();
109 }
110
111
112
113
114
115 public List<ProjectSummary> getProjects( int projectGroupId )
116 throws Exception
117 {
118 return continuum.getProjects( projectGroupId );
119 }
120
121 public ProjectSummary getProjectSummary( int projectId )
122 throws Exception
123 {
124 return continuum.getProjectSummary( projectId );
125 }
126
127 public Project getProjectWithAllDetails( int projectId )
128 throws Exception
129 {
130 return continuum.getProjectWithAllDetails( projectId );
131 }
132
133 public int removeProject( int projectId )
134 throws Exception
135 {
136 return continuum.removeProject( projectId );
137 }
138
139 public ProjectSummary updateProject( ProjectSummary project )
140 throws Exception
141 {
142 return continuum.updateProject( project );
143 }
144
145 public ProjectSummary refreshProjectSummary( ProjectSummary project )
146 throws Exception
147 {
148 if ( project == null )
149 {
150 return null;
151 }
152 return getProjectSummary( project.getId() );
153 }
154
155 public Project refreshProjectWithAllDetails( ProjectSummary project )
156 throws Exception
157 {
158 if ( project == null )
159 {
160 return null;
161 }
162 return getProjectWithAllDetails( project.getId() );
163 }
164
165
166
167
168
169 public List<ProjectGroupSummary> getAllProjectGroups()
170 throws Exception
171 {
172 return continuum.getAllProjectGroups();
173 }
174
175 public List<ProjectGroup> getAllProjectGroupsWithAllDetails()
176 throws Exception
177 {
178 return continuum.getAllProjectGroupsWithAllDetails();
179 }
180
181
182
183
184 public List<ProjectGroup> getAllProjectGroupsWithProjects()
185 throws Exception
186 {
187 return getAllProjectGroupsWithAllDetails();
188 }
189
190 public ProjectGroupSummary getProjectGroupSummary( int projectGroupId )
191 throws Exception
192 {
193 return continuum.getProjectGroupSummary( projectGroupId );
194 }
195
196 public ProjectGroup getProjectGroupWithProjects( int projectGroupId )
197 throws Exception
198 {
199 return continuum.getProjectGroupWithProjects( projectGroupId );
200 }
201
202 public int removeProjectGroup( int projectGroupId )
203 throws Exception
204 {
205 return continuum.removeProjectGroup( projectGroupId );
206 }
207
208 public ProjectGroupSummary refreshProjectGroupSummary( ProjectGroupSummary projectGroup )
209 throws Exception
210 {
211 if ( projectGroup == null )
212 {
213 return null;
214 }
215 return getProjectGroupSummary( projectGroup.getId() );
216 }
217
218 public ProjectGroup refreshProjectGroupSummaryWithProjects( ProjectGroupSummary projectGroup )
219 throws Exception
220 {
221 if ( projectGroup == null )
222 {
223 return null;
224 }
225 return getProjectGroupWithProjects( projectGroup.getId() );
226 }
227
228 public ProjectGroupSummary updateProjectGroup( ProjectGroupSummary projectGroup )
229 throws Exception
230 {
231 return continuum.updateProjectGroup( projectGroup );
232 }
233
234 public ProjectGroupSummary addProjectGroup( ProjectGroupSummary pg )
235 throws Exception
236 {
237 return addProjectGroup( pg.getName(), pg.getGroupId(), pg.getDescription() );
238 }
239
240 public ProjectGroupSummary addProjectGroup( String groupName, String groupId, String description )
241 throws Exception
242 {
243 return continuum.addProjectGroup( groupName, groupId, description );
244 }
245
246
247
248
249
250 public List<BuildDefinition> getBuildDefinitionsForProject( int projectId )
251 throws Exception
252 {
253 return continuum.getBuildDefinitionsForProject( projectId );
254 }
255
256 public List<BuildDefinition> getBuildDefinitionsForProjectGroup( int projectGroupId )
257 throws Exception
258 {
259 return continuum.getBuildDefinitionsForProjectGroup( projectGroupId );
260 }
261
262 public BuildDefinition updateBuildDefinitionForProject( int projectId, BuildDefinition buildDef )
263 throws Exception
264 {
265 return continuum.updateBuildDefinitionForProject( projectId, buildDef );
266 }
267
268 public BuildDefinition updateBuildDefinitionForProjectGroup( int projectGroupId, BuildDefinition buildDef )
269 throws Exception
270 {
271 return continuum.updateBuildDefinitionForProjectGroup( projectGroupId, buildDef );
272 }
273
274 public int removeBuildDefinitionFromProjectGroup( int projectGroupId, int buildDefinitionId )
275 throws Exception
276 {
277 return continuum.removeBuildDefinitionFromProjectGroup( projectGroupId, buildDefinitionId );
278 }
279
280 public BuildDefinition addBuildDefinitionToProject( int projectId, BuildDefinition buildDef )
281 throws Exception
282 {
283 return continuum.addBuildDefinitionToProject( projectId, buildDef );
284 }
285
286 public BuildDefinition addBuildDefinitionToProjectGroup( int projectGroupId, BuildDefinition buildDef )
287 throws Exception
288 {
289 return continuum.addBuildDefinitionToProjectGroup( projectGroupId, buildDef );
290 }
291
292 public List<BuildDefinitionTemplate> getBuildDefinitionTemplates()
293 throws Exception
294 {
295 return continuum.getBuildDefinitionTemplates();
296 }
297
298
299
300
301
302 public int addProjectToBuildQueue( int projectId )
303 throws Exception
304 {
305 return continuum.addProjectToBuildQueue( projectId );
306 }
307
308 public int addProjectToBuildQueue( int projectId, int buildDefinitionId )
309 throws Exception
310 {
311 return continuum.addProjectToBuildQueue( projectId, buildDefinitionId );
312 }
313
314 public int buildProject( int projectId )
315 throws Exception
316 {
317 return continuum.buildProject( projectId );
318 }
319
320 public int buildProject( int projectId, int buildDefinitionId )
321 throws Exception
322 {
323 return continuum.buildProject( projectId, buildDefinitionId );
324 }
325
326 public int buildGroup( int projectGroupId )
327 throws Exception
328 {
329 return continuum.buildGroup( projectGroupId );
330 }
331
332 public int buildGroup( int projectGroupId, int buildDefinitionId )
333 throws Exception
334 {
335 return continuum.buildGroup( projectGroupId, buildDefinitionId );
336 }
337
338
339
340
341
342 public BuildResult getLatestBuildResult( int projectId )
343 throws Exception
344 {
345 return continuum.getLatestBuildResult( projectId );
346 }
347
348 public BuildResult getBuildResult( int projectId, int buildId )
349 throws Exception
350 {
351 return continuum.getBuildResult( projectId, buildId );
352 }
353
354 public List<BuildResultSummary> getBuildResultsForProject( int projectId )
355 throws Exception
356 {
357 return continuum.getBuildResultsForProject( projectId );
358 }
359
360 public int removeBuildResult( BuildResult br )
361 throws Exception
362 {
363 return continuum.removeBuildResult( br );
364 }
365
366 public String getBuildOutput( int projectId, int buildId )
367 throws Exception
368 {
369 return continuum.getBuildOutput( projectId, buildId );
370 }
371
372
373
374
375
376 public AddingResult addMavenTwoProject( String url )
377 throws Exception
378 {
379 return continuum.addMavenTwoProject( url );
380 }
381
382 public AddingResult addMavenTwoProject( String url, int projectGroupId )
383 throws Exception
384 {
385 return continuum.addMavenTwoProject( url, projectGroupId );
386 }
387
388
389
390
391
392 public AddingResult addMavenOneProject( String url, int projectGroupId )
393 throws Exception
394 {
395 return continuum.addMavenOneProject( url, projectGroupId );
396 }
397
398
399
400
401
402 public ProjectSummary addAntProject( ProjectSummary project, int projectGroupId )
403 throws Exception
404 {
405 return continuum.addAntProject( project, projectGroupId );
406 }
407
408
409
410
411
412 public ProjectSummary addShellProject( ProjectSummary project, int projectGroupId )
413 throws Exception
414 {
415 return continuum.addShellProject( project, projectGroupId );
416 }
417
418
419
420
421
422 public List<Schedule> getSchedules()
423 throws Exception
424 {
425 return continuum.getSchedules();
426 }
427
428 public Schedule getSchedule( int scheduleId )
429 throws Exception
430 {
431 return continuum.getSchedule( scheduleId );
432 }
433
434 public Schedule addSchedule( Schedule schedule )
435 throws Exception
436 {
437 return continuum.addSchedule( schedule );
438 }
439
440 public Schedule updateSchedule( Schedule schedule )
441 throws Exception
442 {
443 return continuum.updateSchedule( schedule );
444 }
445
446
447
448
449
450 public List<Profile> getProfiles()
451 throws Exception
452 {
453 return continuum.getProfiles();
454 }
455
456 public Profile getProfile( int profileId )
457 throws Exception
458 {
459 return continuum.getProfile( profileId );
460 }
461
462
463
464
465
466 public List<Installation> getInstallations()
467 throws Exception
468 {
469 return continuum.getInstallations();
470 }
471
472 public Installation getInstallation( int installationId )
473 throws Exception
474 {
475 return continuum.getInstallation( installationId );
476 }
477
478
479
480
481
482 public SystemConfiguration getSystemConfiguration()
483 throws Exception
484 {
485 return continuum.getSystemConfiguration();
486 }
487
488
489
490
491
492 public String getProjectStatusAsString( int status )
493 {
494 return statusMap.get( new Integer( status ) );
495 }
496
497
498
499
500
501 public List<BuildProjectTask> getProjectsInBuildQueue()
502 throws Exception
503 {
504 return continuum.getProjectsInBuildQueue();
505 }
506
507 public boolean isProjectInBuildingQueue( int projectId )
508 throws Exception
509 {
510 return continuum.isProjectInBuildingQueue( projectId );
511 }
512
513 public int removeProjectsFromBuildingQueue( int[] projectsId )
514 throws Exception
515 {
516 return continuum.removeProjectsFromBuildingQueue( projectsId );
517 }
518
519 public boolean cancelCurrentBuild()
520 throws Exception
521 {
522 return continuum.cancelCurrentBuild();
523 }
524
525
526
527
528
529 public ContinuumReleaseResult getReleaseResult( int releaseId )
530 throws Exception
531 {
532 return continuum.getReleaseResult( releaseId );
533 }
534
535 public List<ContinuumReleaseResult> getReleaseResultsForProjectGroup( int projectGroupId )
536 throws Exception
537 {
538 return continuum.getReleaseResultsForProjectGroup( projectGroupId );
539 }
540
541 public int removeReleaseResult( ContinuumReleaseResult releaseResult )
542 throws Exception
543 {
544 return continuum.removeReleaseResult( releaseResult );
545 }
546
547 public String getReleaseOutput( int releaseId )
548 throws Exception
549 {
550 return continuum.getReleaseOutput( releaseId );
551 }
552
553
554
555
556
557 public RepositoryPurgeConfiguration addRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
558 throws Exception
559 {
560 return continuum.addRepositoryPurgeConfiguration( repoPurge );
561 }
562
563 public int updateRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge )
564 throws Exception
565 {
566 return continuum.updateRepositoryPurgeConfiguration( repoPurge );
567 }
568
569 public int removeRepositoryPurgeConfiguration( int repoPurgeId )
570 throws Exception
571 {
572 return continuum.removeRepositoryPurgeConfiguration( repoPurgeId );
573 }
574
575 public RepositoryPurgeConfiguration getRepositoryPurgeConfiguration( int repoPurgeId )
576 throws Exception
577 {
578 return continuum.getRepositoryPurgeConfiguration( repoPurgeId );
579 }
580
581 public List<RepositoryPurgeConfiguration> getAllRepositoryPurgeConfigurations()
582 throws Exception
583 {
584 return continuum.getAllRepositoryPurgeConfigurations();
585 }
586
587 public DirectoryPurgeConfiguration addDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
588 throws Exception
589 {
590 return continuum.addDirectoryPurgeConfiguration( dirPurge );
591 }
592
593 public int updateDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge )
594 throws Exception
595 {
596 return continuum.updateDirectoryPurgeConfiguration( dirPurge );
597 }
598
599 public int removeDirectoryPurgeConfiguration( int dirPurgeId )
600 throws Exception
601 {
602 return continuum.removeDirectoryPurgeConfiguration( dirPurgeId );
603 }
604
605 public DirectoryPurgeConfiguration getDirectoryPurgeConfiguration( int dirPurgeId )
606 throws Exception
607 {
608 return continuum.getDirectoryPurgeConfiguration( dirPurgeId );
609 }
610
611 public List<DirectoryPurgeConfiguration> getAllDirectoryPurgeConfigurations()
612 throws Exception
613 {
614 return continuum.getAllDirectoryPurgeConfigurations();
615 }
616
617 public void purgeLocalRepository( int repoPurgeId )
618 throws Exception
619 {
620 continuum.purgeLocalRepository( repoPurgeId );
621 }
622
623 public void purgeDirectory( int dirPurgeId )
624 throws Exception
625 {
626 continuum.purgeDirectory( dirPurgeId );
627 }
628
629
630
631
632
633 public LocalRepository addLocalRepository( LocalRepository repository )
634 throws Exception
635 {
636 return continuum.addLocalRepository( repository );
637 }
638
639 public int updateLocalRepository( LocalRepository repository )
640 throws Exception
641 {
642 return continuum.updateLocalRepository( repository );
643 }
644
645 public int removeLocalRepository( int repositoryId )
646 throws Exception
647 {
648 return continuum.removeLocalRepository( repositoryId );
649 }
650
651 public LocalRepository getLocalRepository( int repositoryId )
652 throws Exception
653 {
654 return continuum.getLocalRepository( repositoryId );
655 }
656
657 public List<LocalRepository> getAllLocalRepositories()
658 throws Exception
659 {
660 return continuum.getAllLocalRepositories();
661 }
662
663 public Map<String, Object> addAntProjectRPC( Map<String, Object> project, int projectGroupId )
664 throws Exception
665 {
666 return continuum.addAntProjectRPC( project, projectGroupId );
667 }
668
669 public Map<String, Object> addBuildDefinitionToProjectGroupRPC( int projectGroupId, Map<String, Object> buildDef )
670 throws Exception
671 {
672 return continuum.addBuildDefinitionToProjectGroupRPC( projectGroupId, buildDef );
673 }
674
675 public Map<String, Object> addBuildDefinitionToProjectRPC( int projectId, Map<String, Object> buildDef )
676 throws Exception
677 {
678 return continuum.addBuildDefinitionToProjectRPC( projectId, buildDef );
679 }
680
681 public Map<String, Object> addMavenOneProjectRPC( String url, int projectGroupId )
682 throws Exception
683 {
684 return continuum.addMavenOneProjectRPC( url, projectGroupId );
685 }
686
687 public Map<String, Object> addMavenTwoProjectRPC( String url )
688 throws Exception
689 {
690 return continuum.addMavenTwoProjectRPC( url );
691 }
692
693 public Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId )
694 throws Exception
695 {
696 return continuum.addMavenTwoProjectRPC( url, projectGroupId );
697 }
698
699 public Map<String, Object> addProjectGroupRPC( String groupName, String groupId, String description )
700 throws Exception
701 {
702 return continuum.addProjectGroupRPC( groupName, groupId, description );
703 }
704
705 public Map<String, Object> addScheduleRPC( Map<String, Object> schedule )
706 throws Exception
707 {
708 return continuum.addScheduleRPC( schedule );
709 }
710
711 public Map<String, Object> addShellProjectRPC( Map<String, Object> project, int projectGroupId )
712 throws Exception
713 {
714 return continuum.addShellProjectRPC( project, projectGroupId );
715 }
716
717 public List<Object> getAllProjectGroupsRPC()
718 throws Exception
719 {
720 return continuum.getAllProjectGroupsRPC();
721 }
722
723 public List<Object> getAllProjectGroupsWithAllDetailsRPC()
724 throws Exception
725 {
726 return continuum.getAllProjectGroupsWithAllDetailsRPC();
727 }
728
729 public List<Object> getBuildDefinitionTemplatesRPC()
730 throws Exception
731 {
732 return continuum.getBuildDefinitionTemplatesRPC();
733 }
734
735 public List<Object> getBuildDefinitionsForProjectGroupRPC( int projectGroupId )
736 throws Exception
737 {
738 return continuum.getBuildDefinitionsForProjectGroupRPC( projectGroupId );
739 }
740
741 public List<Object> getBuildDefinitionsForProjectRPC( int projectId )
742 throws Exception
743 {
744 return continuum.getBuildDefinitionsForProjectRPC( projectId );
745 }
746
747 public Map<String, Object> getBuildResultRPC( int projectId, int buildId )
748 throws Exception
749 {
750 return continuum.getBuildResultRPC( projectId, buildId );
751 }
752
753 public List<Object> getBuildResultsForProjectRPC( int projectId )
754 throws Exception
755 {
756 return continuum.getBuildResultsForProjectRPC( projectId );
757 }
758
759 public Map<String, Object> getInstallationRPC( int installationId )
760 throws Exception
761 {
762 return continuum.getInstallationRPC( installationId );
763 }
764
765 public List<Object> getInstallationsRPC()
766 throws Exception
767 {
768 return continuum.getInstallationsRPC();
769 }
770
771 public Map<String, Object> getLatestBuildResultRPC( int projectId )
772 throws Exception
773 {
774 return continuum.getLatestBuildResultRPC( projectId );
775 }
776
777 public Map<String, Object> getProfileRPC( int profileId )
778 throws Exception
779 {
780 return continuum.getProfileRPC( profileId );
781 }
782
783 public List<Object> getProfilesRPC()
784 throws Exception
785 {
786 return continuum.getProfilesRPC();
787 }
788
789 public Map<String, Object> getProjectGroupSummaryRPC( int projectGroupId )
790 throws Exception
791 {
792 return continuum.getProjectGroupSummaryRPC( projectGroupId );
793 }
794
795 public Map<String, Object> getProjectGroupWithProjectsRPC( int projectGroupId )
796 throws Exception
797 {
798 return continuum.getProjectGroupWithProjectsRPC( projectGroupId );
799 }
800
801 public Map<String, Object> updateProjectGroupRPC( Map<String, Object> projectGroup )
802 throws Exception
803 {
804 return continuum.updateProjectGroupRPC( projectGroup );
805 }
806
807 public Map<String, Object> getProjectSummaryRPC( int projectId )
808 throws Exception
809 {
810 return continuum.getProjectSummaryRPC( projectId );
811 }
812
813 public Map<String, Object> getProjectWithAllDetailsRPC( int projectId )
814 throws Exception
815 {
816 return continuum.getProjectWithAllDetailsRPC( projectId );
817 }
818
819 public List<Object> getProjectsRPC( int projectGroupId )
820 throws Exception
821 {
822 return continuum.getProjectsRPC( projectGroupId );
823 }
824
825 public Map<String, Object> getScheduleRPC( int scheduleId )
826 throws Exception
827 {
828 return continuum.getScheduleRPC( scheduleId );
829 }
830
831 public List<Object> getSchedulesRPC()
832 throws Exception
833 {
834 return continuum.getSchedulesRPC();
835 }
836
837 public Map<String, Object> getSystemConfigurationRPC()
838 throws Exception
839 {
840 return continuum.getSystemConfigurationRPC();
841 }
842
843 public int removeBuildResultRPC( Map<String, Object> br )
844 throws Exception
845 {
846 return continuum.removeBuildResultRPC( br );
847 }
848
849 public Map<String, Object> updateBuildDefinitionForProjectGroupRPC( int projectGroupId,
850 Map<String, Object> buildDef )
851 throws Exception
852 {
853 return continuum.updateBuildDefinitionForProjectGroupRPC( projectGroupId, buildDef );
854 }
855
856 public Map<String, Object> updateBuildDefinitionForProjectRPC( int projectId, Map<String, Object> buildDef )
857 throws Exception
858 {
859 return continuum.updateBuildDefinitionForProjectRPC( projectId, buildDef );
860 }
861
862 public Map<String, Object> updateProjectRPC( Map<String, Object> project )
863 throws Exception
864 {
865 return continuum.updateProjectRPC( project );
866 }
867
868 public Map<String, Object> updateScheduleRPC( Map<String, Object> schedule )
869 throws Exception
870 {
871 return continuum.updateScheduleRPC( schedule );
872 }
873
874 public ProjectGroup getProjectGroup( int projectGroupId )
875 throws Exception
876 {
877 return continuum.getProjectGroup( projectGroupId );
878 }
879
880 public Map<String, Object> getProjectGroupRPC( int projectGroupId )
881 throws Exception
882 {
883 return continuum.getProjectGroupRPC( projectGroupId );
884 }
885
886 public ProjectNotifier getGroupNotifier( int projectgroupid, int notifierId )
887 throws Exception
888 {
889 return continuum.getGroupNotifier( projectgroupid, notifierId );
890 }
891
892 public Map<String, Object> getGroupNotifierRPC( int projectgroupid, int notifierId )
893 throws Exception
894 {
895 return continuum.getGroupNotifierRPC( projectgroupid, notifierId );
896 }
897
898 public ProjectNotifier getNotifier( int projectid, int notifierId )
899 throws Exception
900 {
901 return continuum.getNotifier( projectid, notifierId );
902 }
903
904 public Map<String, Object> getNotifierRPC( int projectid, int notifierId )
905 throws Exception
906 {
907 return continuum.getNotifierRPC( projectid, notifierId );
908 }
909
910 public ProjectNotifier updateGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
911 throws Exception
912 {
913 return continuum.updateGroupNotifier( projectgroupid, newNotifier );
914 }
915
916 public Map<String, Object> updateGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
917 throws Exception
918 {
919 return continuum.updateGroupNotifierRPC( projectgroupid, newNotifier );
920 }
921
922 public ProjectNotifier updateNotifier( int projectid, ProjectNotifier newNotifier )
923 throws Exception
924 {
925 return continuum.updateNotifier( projectid, newNotifier );
926 }
927
928 public Map<String, Object> updateNotifierRPC( int projectid, Map<String, Object> newNotifier )
929 throws Exception
930 {
931 return continuum.updateNotifierRPC( projectid, newNotifier );
932 }
933
934 public int removeGroupNotifier( int projectgroupid, int notifierId )
935 throws Exception
936 {
937 return continuum.removeGroupNotifier( projectgroupid, notifierId );
938 }
939
940 public int removeNotifier( int projectid, int notifierId )
941 throws Exception
942 {
943 return continuum.removeNotifier( projectid, notifierId );
944 }
945
946 public ProjectNotifier addGroupNotifier( int projectgroupid, ProjectNotifier newNotifier )
947 throws Exception
948 {
949 return continuum.addGroupNotifier( projectgroupid, newNotifier );
950 }
951
952 public Map<String, Object> addGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier )
953 throws Exception
954 {
955 return continuum.addGroupNotifierRPC( projectgroupid, newNotifier );
956 }
957
958 public ProjectNotifier addNotifier( int projectid, ProjectNotifier newNotifier )
959 throws Exception
960 {
961 return continuum.addNotifier( projectid, newNotifier );
962 }
963
964 public Map<String, Object> addNotifierRPC( int projectid, Map<String, Object> newNotifier )
965 throws Exception
966 {
967 return continuum.addNotifierRPC( projectid, newNotifier );
968 }
969
970 public Installation addInstallation( Installation installation )
971 throws Exception
972 {
973 return continuum.addInstallation( installation );
974 }
975
976 public Map<String, Object> addInstallationRPC( Map<String, Object> installation )
977 throws Exception
978 {
979 return continuum.addInstallationRPC( installation );
980 }
981
982 public Profile addProfile( Profile profile )
983 throws Exception
984 {
985 return continuum.addProfile( profile );
986 }
987
988 public Map<String, Object> addProfileRPC( Map<String, Object> profile )
989 throws Exception
990 {
991 return continuum.addProfileRPC( profile );
992 }
993
994 public int deleteInstallation( int installationId )
995 throws Exception
996 {
997 return continuum.deleteInstallation( installationId );
998 }
999
1000 public int deleteProfile( int profileId )
1001 throws Exception
1002 {
1003 return continuum.deleteProfile( profileId );
1004 }
1005
1006 public int updateInstallation( Installation installation )
1007 throws Exception
1008 {
1009 return continuum.updateInstallation( installation );
1010 }
1011
1012 public int updateInstallationRPC( Map<String, Object> installation )
1013 throws Exception
1014 {
1015 return continuum.updateInstallationRPC( installation );
1016 }
1017
1018 public int updateProfile( Profile profile )
1019 throws Exception
1020 {
1021 return continuum.updateProfile( profile );
1022 }
1023
1024 public int updateProfileRPC( Map<String, Object> profile )
1025 throws Exception
1026 {
1027 return continuum.updateProfileRPC( profile );
1028 }
1029
1030 public Map<String, Object> getReleaseResultRPC( int releaseId )
1031 throws Exception
1032 {
1033 return continuum.getReleaseResultRPC( releaseId );
1034 }
1035
1036 public List<Object> getReleaseResultsForProjectGroupRPC( int projectGroupId )
1037 throws Exception
1038 {
1039 return continuum.getReleaseResultsForProjectGroupRPC( projectGroupId );
1040 }
1041
1042 public int removeReleaseResultRPC( Map<String, Object> rr )
1043 throws Exception
1044 {
1045 return continuum.removeReleaseResultRPC( rr );
1046 }
1047
1048 public Map<String, Object> addRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
1049 throws Exception
1050 {
1051 return continuum.addRepositoryPurgeConfigurationRPC( repoPurge );
1052 }
1053
1054 public int updateRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge )
1055 throws Exception
1056 {
1057 return continuum.updateRepositoryPurgeConfigurationRPC( repoPurge );
1058 }
1059
1060 public Map<String, Object> getRepositoryPurgeConfigurationRPC( int repoPurgeId )
1061 throws Exception
1062 {
1063 return continuum.getRepositoryPurgeConfigurationRPC( repoPurgeId );
1064 }
1065
1066 public List<Object> getAllRepositoryPurgeConfigurationsRPC()
1067 throws Exception
1068 {
1069 return continuum.getAllRepositoryPurgeConfigurationsRPC();
1070 }
1071
1072 public Map<String, Object> addDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
1073 throws Exception
1074 {
1075 return continuum.addDirectoryPurgeConfigurationRPC( dirPurge );
1076 }
1077
1078 public int updateDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge )
1079 throws Exception
1080 {
1081 return continuum.updateDirectoryPurgeConfigurationRPC( dirPurge );
1082 }
1083
1084 public Map<String, Object> getDirectoryPurgeConfigurationRPC( int dirPurgeId )
1085 throws Exception
1086 {
1087 return continuum.getDirectoryPurgeConfigurationRPC( dirPurgeId );
1088 }
1089
1090 public List<Object> getAllDirectoryPurgeConfigurationsRPC()
1091 throws Exception
1092 {
1093 return continuum.getAllDirectoryPurgeConfigurationsRPC();
1094 }
1095
1096 public Map<String, Object> addLocalRepositoryRPC( Map<String, Object> repository )
1097 throws Exception
1098 {
1099 return continuum.addLocalRepositoryRPC( repository );
1100 }
1101
1102 public int updateLocalRepositoryRPC( Map<String, Object> repository )
1103 throws Exception
1104 {
1105 return continuum.updateLocalRepositoryRPC( repository );
1106 }
1107
1108 public Map<String, Object> getLocalRepositoryRPC( int repositoryId )
1109 throws Exception
1110 {
1111 return continuum.getLocalRepositoryRPC( repositoryId );
1112 }
1113
1114 public List<Object> getAllLocalRepositoriesRPC()
1115 throws Exception
1116 {
1117 return continuum.getAllLocalRepositoriesRPC();
1118 }
1119 }