1 package org.apache.maven.continuum.xmlrpc; 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.project.AddingResult; 28 import org.apache.maven.continuum.xmlrpc.project.BuildAgentConfiguration; 29 import org.apache.maven.continuum.xmlrpc.project.BuildAgentGroupConfiguration; 30 import org.apache.maven.continuum.xmlrpc.project.BuildDefinition; 31 import org.apache.maven.continuum.xmlrpc.project.BuildDefinitionTemplate; 32 import org.apache.maven.continuum.xmlrpc.project.BuildProjectTask; 33 import org.apache.maven.continuum.xmlrpc.project.BuildResult; 34 import org.apache.maven.continuum.xmlrpc.project.BuildResultSummary; 35 import org.apache.maven.continuum.xmlrpc.project.Project; 36 import org.apache.maven.continuum.xmlrpc.project.ProjectGroup; 37 import org.apache.maven.continuum.xmlrpc.project.ProjectGroupSummary; 38 import org.apache.maven.continuum.xmlrpc.project.ProjectNotifier; 39 import org.apache.maven.continuum.xmlrpc.project.ProjectScmRoot; 40 import org.apache.maven.continuum.xmlrpc.project.ProjectSummary; 41 import org.apache.maven.continuum.xmlrpc.project.ReleaseListenerSummary; 42 import org.apache.maven.continuum.xmlrpc.project.Schedule; 43 import org.apache.maven.continuum.xmlrpc.system.Installation; 44 import org.apache.maven.continuum.xmlrpc.system.Profile; 45 import org.apache.maven.continuum.xmlrpc.system.SystemConfiguration; 46 47 import java.util.List; 48 import java.util.Map; 49 import java.util.Properties; 50 51 /** 52 * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a> 53 * @version $Id: ContinuumService.java 1372260 2012-08-13 04:29:09Z brett $ 54 */ 55 public interface ContinuumService 56 { 57 // ---------------------------------------------------------------------- 58 // Projects 59 // ---------------------------------------------------------------------- 60 61 /** 62 * Get All projects. 63 * 64 * @param projectGroupId The project group Id 65 * @return List of {@link ProjectSummary} 66 * @throws Exception 67 */ 68 List<ProjectSummary> getProjects( int projectGroupId ) 69 throws Exception; 70 71 /** 72 * Same method but compatible with standard XMLRPC 73 * 74 * @param projectGroupId The project group Id 75 * @return List of {@link ProjectSummary} as RPC value 76 * @throws Exception 77 */ 78 List<Object> getProjectsRPC( int projectGroupId ) 79 throws Exception; 80 81 /** 82 * Get a project. 83 * 84 * @param projectId the project id 85 * @return The project summary 86 * @throws Exception 87 */ 88 ProjectSummary getProjectSummary( int projectId ) 89 throws Exception; 90 91 /** 92 * Same method but compatible with standard XMLRPC 93 * 94 * @param projectId the project id 95 * @return The project summary as RPC value 96 * @throws Exception 97 */ 98 Map<String, Object> getProjectSummaryRPC( int projectId ) 99 throws Exception; 100 101 /** 102 * Get a project with all details. 103 * 104 * @param projectId The project id 105 * @return The project 106 * @throws Exception 107 */ 108 Project getProjectWithAllDetails( int projectId ) 109 throws Exception; 110 111 /** 112 * Same method but compatible with standard XMLRPC 113 * 114 * @param projectId the project id 115 * @return The project as RPC value 116 * @throws Exception 117 */ 118 Map<String, Object> getProjectWithAllDetailsRPC( int projectId ) 119 throws Exception; 120 121 /** 122 * Remove a project. 123 * 124 * @param projectId The project id 125 * @throws Exception 126 */ 127 int removeProject( int projectId ) 128 throws Exception; 129 130 /** 131 * Update a project. Useful to change the scm parameters. 132 * 133 * @param project The project to update 134 * @throws Exception 135 */ 136 ProjectSummary updateProject( ProjectSummary project ) 137 throws Exception; 138 139 /** 140 * Same method but compatible with standard XMLRPC 141 * 142 * @param project The project to update 143 * @return The project as RPC value 144 * @throws Exception 145 */ 146 Map<String, Object> updateProjectRPC( Map<String, Object> project ) 147 throws Exception; 148 149 // ---------------------------------------------------------------------- 150 // Projects Groups 151 // ---------------------------------------------------------------------- 152 153 /** 154 * Get a project groups. 155 * 156 * @param projectGroupId the id 157 * @return project group 158 * @throws Exception 159 */ 160 ProjectGroup getProjectGroup( int projectGroupId ) 161 throws Exception; 162 163 /** 164 * Same method but compatible with standard XMLRPC 165 * 166 * @param projectGroupId the id 167 * @return project group as RPC value 168 * @throws Exception 169 */ 170 Map<String, Object> getProjectGroupRPC( int projectGroupId ) 171 throws Exception; 172 173 /** 174 * Get all project groups. 175 * 176 * @return All project groups 177 * @throws Exception 178 */ 179 List<ProjectGroupSummary> getAllProjectGroups() 180 throws Exception; 181 182 /** 183 * Same method but compatible with standard XMLRPC 184 * 185 * @return List of {@link ProjectGroupSummary} as RPC value 186 * @throws Exception 187 */ 188 List<Object> getAllProjectGroupsRPC() 189 throws Exception; 190 191 /** 192 * Get all project groups with all details (project summaries, notifiers, build definitions). 193 * 194 * @return All project groups 195 * @throws Exception 196 */ 197 List<ProjectGroup> getAllProjectGroupsWithAllDetails() 198 throws Exception; 199 200 /** 201 * Same method but compatible with standard XMLRPC 202 * 203 * @return List of {@link ProjectGroup} as RPC value 204 * @throws Exception 205 */ 206 List<Object> getAllProjectGroupsWithAllDetailsRPC() 207 throws Exception; 208 209 /** 210 * Get all project groups with all details. 211 * 212 * @return All project groups 213 * @throws Exception 214 * @deprecated 215 */ 216 List<ProjectGroup> getAllProjectGroupsWithProjects() 217 throws Exception; 218 219 /** 220 * Get a project group. 221 * 222 * @param projectGroupId The project group id 223 * @return The project group summary 224 * @throws Exception 225 */ 226 ProjectGroupSummary getProjectGroupSummary( int projectGroupId ) 227 throws Exception; 228 229 /** 230 * Same method but compatible with standard XMLRPC 231 * 232 * @param projectGroupId The project group id 233 * @return The project group summary as RPC value 234 * @throws Exception 235 */ 236 Map<String, Object> getProjectGroupSummaryRPC( int projectGroupId ) 237 throws Exception; 238 239 /** 240 * Get a project group with all details. 241 * 242 * @param projectGroupId The project group id 243 * @return The project group 244 * @throws Exception 245 */ 246 ProjectGroup getProjectGroupWithProjects( int projectGroupId ) 247 throws Exception; 248 249 /** 250 * Same method but compatible with standard XMLRPC 251 * 252 * @param projectGroupId The project group id 253 * @return The project group as RPC value 254 * @throws Exception 255 */ 256 Map<String, Object> getProjectGroupWithProjectsRPC( int projectGroupId ) 257 throws Exception; 258 259 /** 260 * Remove a project group. 261 * 262 * @param projectGroupId The project group id 263 * @throws Exception 264 */ 265 int removeProjectGroup( int projectGroupId ) 266 throws Exception; 267 268 /** 269 * Update a project Group. 270 * 271 * @param projectGroup The project group to update 272 * @throws Exception 273 */ 274 ProjectGroupSummary updateProjectGroup( ProjectGroupSummary projectGroup ) 275 throws Exception; 276 277 /** 278 * Same method but compatible with standard XMLRPC 279 * 280 * @param projectGroup The project group to update 281 * @return The project group as RPC value 282 * @throws Exception 283 */ 284 Map<String, Object> updateProjectGroupRPC( Map<String, Object> projectGroup ) 285 throws Exception; 286 287 /** 288 * Add a project Group. 289 * 290 * @param groupName The project group name 291 * @param groupId The project group id 292 * @param description The project group description 293 * @return the project group summary of the created project group 294 * @throws Exception 295 */ 296 ProjectGroupSummary addProjectGroup( String groupName, String groupId, String description ) 297 throws Exception; 298 299 int removeBuildDefinitionFromProjectGroup( int projectGroupId, int buildDefinitionId ) 300 throws Exception; 301 302 /** 303 * Same method but compatible with standard XMLRPC 304 * 305 * @param groupName The project group name 306 * @param groupId The project group id 307 * @param description The project group description 308 * @return the project group summary of the created project group as RPC value 309 * @throws Exception 310 */ 311 Map<String, Object> addProjectGroupRPC( String groupName, String groupId, String description ) 312 throws Exception; 313 314 ProjectNotifier getNotifier( int projectid, int notifierId ) 315 throws Exception; 316 317 Map<String, Object> getNotifierRPC( int projectid, int notifierId ) 318 throws Exception; 319 320 ProjectNotifier getGroupNotifier( int projectgroupid, int notifierId ) 321 throws Exception; 322 323 Map<String, Object> getGroupNotifierRPC( int projectgroupid, int notifierId ) 324 throws Exception; 325 326 ProjectNotifier updateGroupNotifier( int projectgroupid, ProjectNotifier newNotifier ) 327 throws Exception; 328 329 Map<String, Object> updateGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier ) 330 throws Exception; 331 332 ProjectNotifier updateNotifier( int projectid, ProjectNotifier newNotifier ) 333 throws Exception; 334 335 Map<String, Object> updateNotifierRPC( int projectid, Map<String, Object> newNotifier ) 336 throws Exception; 337 338 int removeGroupNotifier( int projectgroupid, int notifierId ) 339 throws Exception; 340 341 int removeNotifier( int projectid, int notifierId ) 342 throws Exception; 343 344 ProjectNotifier addNotifier( int projectid, ProjectNotifier newNotifier ) 345 throws Exception; 346 347 ProjectNotifier addGroupNotifier( int projectgroupid, ProjectNotifier newNotifier ) 348 throws Exception; 349 350 Map<String, Object> addNotifierRPC( int projectid, Map<String, Object> newNotifier ) 351 throws Exception; 352 353 Map<String, Object> addGroupNotifierRPC( int projectgroupid, Map<String, Object> newNotifier ) 354 throws Exception; 355 356 // ---------------------------------------------------------------------- 357 // Build Definitions 358 // ---------------------------------------------------------------------- 359 360 /** 361 * Get the build definitions list of the project. 362 * 363 * @param projectId The project id 364 * @return The build definitions list 365 * @throws Exception 366 */ 367 List<BuildDefinition> getBuildDefinitionsForProject( int projectId ) 368 throws Exception; 369 370 /** 371 * Same method but compatible with standard XMLRPC 372 * 373 * @param projectId The project id 374 * @return The build definitions list as RPC value 375 * @throws Exception 376 */ 377 List<Object> getBuildDefinitionsForProjectRPC( int projectId ) 378 throws Exception; 379 380 /** 381 * Get the build definitions list of the project group. 382 * 383 * @param projectGroupId The project group id 384 * @return The build definitions list 385 * @throws Exception 386 */ 387 List<BuildDefinition> getBuildDefinitionsForProjectGroup( int projectGroupId ) 388 throws Exception; 389 390 /** 391 * Same method but compatible with standard XMLRPC 392 * 393 * @param projectGroupId The project group id 394 * @return The build definitions list as RPC value 395 * @throws Exception 396 */ 397 List<Object> getBuildDefinitionsForProjectGroupRPC( int projectGroupId ) 398 throws Exception; 399 400 /** 401 * Get the build definition 402 * 403 * @param buildDefinitionId The build definition id 404 * @return The build definition 405 * @throws Exception 406 */ 407 BuildDefinition getBuildDefinition( int buildDefinitionId ) 408 throws Exception; 409 410 /** 411 * Same method but compatible with standard XMLRPC 412 * 413 * @param buildDefinitionId The build definition id 414 * @return The build definition as RPC value 415 * @throws Exception 416 */ 417 Map<String, Object> getBuildDefinitionRPC( int buildDefinitionId ) 418 throws Exception; 419 420 /** 421 * Update a project build definition. 422 * 423 * @param projectId The project id 424 * @param buildDef The build definition to update 425 * @return the updated build definition 426 * @throws Exception 427 */ 428 BuildDefinition updateBuildDefinitionForProject( int projectId, BuildDefinition buildDef ) 429 throws Exception; 430 431 /** 432 * Same method but compatible with standard XMLRPC 433 * 434 * @param projectId The project id 435 * @param buildDef The build definition to update 436 * @return the updated build definition as RPC value 437 * @throws Exception 438 */ 439 Map<String, Object> updateBuildDefinitionForProjectRPC( int projectId, Map<String, Object> buildDef ) 440 throws Exception; 441 442 /** 443 * Update a project group build definition. 444 * 445 * @param projectGroupId The project group id 446 * @param buildDef The build definition to update 447 * @return the updated build definition 448 * @throws Exception 449 */ 450 BuildDefinition updateBuildDefinitionForProjectGroup( int projectGroupId, BuildDefinition buildDef ) 451 throws Exception; 452 453 /** 454 * Same method but compatible with standard XMLRPC 455 * 456 * @param projectGroupId The project group id 457 * @param buildDef The build definition to update 458 * @return the updated build definition as RPC value 459 * @throws Exception 460 */ 461 Map<String, Object> updateBuildDefinitionForProjectGroupRPC( int projectGroupId, Map<String, Object> buildDef ) 462 throws Exception; 463 464 /** 465 * Add a project build definition. 466 * 467 * @param projectId The project id 468 * @param buildDef The build definition to update 469 * @return the added build definition 470 * @throws Exception 471 */ 472 BuildDefinition addBuildDefinitionToProject( int projectId, BuildDefinition buildDef ) 473 throws Exception; 474 475 /** 476 * Same method but compatible with standard XMLRPC 477 * 478 * @param projectId The project id 479 * @param buildDef The build definition to update 480 * @return the added build definition as RPC value 481 * @throws Exception 482 */ 483 Map<String, Object> addBuildDefinitionToProjectRPC( int projectId, Map<String, Object> buildDef ) 484 throws Exception; 485 486 /** 487 * Add a project group buildDefinition. 488 * 489 * @param projectGroupId The project group id 490 * @param buildDef The build definition to update 491 * @return the build definition added 492 * @throws Exception 493 */ 494 BuildDefinition addBuildDefinitionToProjectGroup( int projectGroupId, BuildDefinition buildDef ) 495 throws Exception; 496 497 /** 498 * Same method but compatible with standard XMLRPC 499 * 500 * @param projectGroupId The project group id 501 * @param buildDef The build definition to update 502 * @return the added build definition as RPC value 503 * @throws Exception 504 */ 505 Map<String, Object> addBuildDefinitionToProjectGroupRPC( int projectGroupId, Map<String, Object> buildDef ) 506 throws Exception; 507 508 /** 509 * Get the build definition templates list. 510 * 511 * @return The build definitions templates list 512 * @throws Exception 513 */ 514 List<BuildDefinitionTemplate> getBuildDefinitionTemplates() 515 throws Exception; 516 517 /** 518 * Same method but compatible with standard XMLRPC 519 * 520 * @return The build definitions templates list as RPC value 521 * @throws Exception 522 */ 523 List<Object> getBuildDefinitionTemplatesRPC() 524 throws Exception; 525 526 // ---------------------------------------------------------------------- 527 // Building 528 // ---------------------------------------------------------------------- 529 530 /** 531 * Add the project to the build queue. 532 * 533 * @param projectId The project id 534 * @throws Exception 535 */ 536 int addProjectToBuildQueue( int projectId ) 537 throws Exception; 538 539 /** 540 * Add the project to the build queue. 541 * 542 * @param projectId The project id 543 * @param buildDefinitionId The build definition id 544 * @throws Exception 545 */ 546 int addProjectToBuildQueue( int projectId, int buildDefinitionId ) 547 throws Exception; 548 549 /** 550 * Build the project 551 * 552 * @param projectId The project id 553 * @throws Exception 554 */ 555 int buildProject( int projectId ) 556 throws Exception; 557 558 /** 559 * Build the project 560 * 561 * @param projectId The project id 562 * @param buildDefinitionId The build definition id 563 * @throws Exception 564 */ 565 int buildProject( int projectId, int buildDefinitionId ) 566 throws Exception; 567 568 /** 569 * Forced build the project 570 * 571 * @param projectId The project id 572 * @param buildTrigger The build trigger 573 * @return 574 * @throws Exception 575 */ 576 int buildProject( int projectId, BuildTrigger buildTrigger ) 577 throws Exception; 578 579 /** 580 * Forced build the project 581 * 582 * @param projectId The project id 583 * @param buildDefinitionId The build definition id 584 * @param buildTrigger The build trigger 585 * @return 586 * @throws Exception 587 */ 588 int buildProject( int projectId, int buildDefinitionId, BuildTrigger buildTrigger ) 589 throws Exception; 590 591 /** 592 * Build the project group with the default build definition. 593 * 594 * @param projectGroupId The project group id 595 * @throws Exception 596 */ 597 int buildGroup( int projectGroupId ) 598 throws Exception; 599 600 /** 601 * Build the project group with the specified build definition. 602 * 603 * @param projectGroupId The project group id 604 * @param buildDefinitionId The build definition id 605 * @throws Exception 606 */ 607 int buildGroup( int projectGroupId, int buildDefinitionId ) 608 throws Exception; 609 610 // ---------------------------------------------------------------------- 611 // SCM roots 612 // ---------------------------------------------------------------------- 613 614 /** 615 * Get the SCM roots for all projects in a project group 616 * 617 * @param projectGroupId the project group id 618 * @return 619 * @throws Exception 620 */ 621 List<ProjectScmRoot> getProjectScmRootByProjectGroup( int projectGroupId ) 622 throws Exception; 623 624 /** 625 * Get the SCM root for a specific project 626 * 627 * @param projectId the project id 628 * @return 629 * @throws Exception 630 */ 631 ProjectScmRoot getProjectScmRootByProject( int projectId ) 632 throws Exception; 633 634 // ---------------------------------------------------------------------- 635 // Build Results 636 // ---------------------------------------------------------------------- 637 638 /** 639 * Returns the latest build result for the project. 640 * 641 * @param projectId The project id 642 * @return The build result 643 * @throws Exception 644 */ 645 BuildResult getLatestBuildResult( int projectId ) 646 throws Exception; 647 648 /** 649 * Same method but compatible with standard XMLRPC 650 * 651 * @param projectId The project id 652 * @return The build result as RPC value 653 * @throws Exception 654 */ 655 Map<String, Object> getLatestBuildResultRPC( int projectId ) 656 throws Exception; 657 658 /** 659 * Returns the build result. 660 * 661 * @param projectId The project id 662 * @param buildId The build id 663 * @return The build result 664 * @throws Exception 665 */ 666 BuildResult getBuildResult( int projectId, int buildId ) 667 throws Exception; 668 669 /** 670 * Same method but compatible with standard XMLRPC 671 * 672 * @param projectId The project id 673 * @param buildId The build id 674 * @return The build result as RPC value 675 * @throws Exception 676 */ 677 Map<String, Object> getBuildResultRPC( int projectId, int buildId ) 678 throws Exception; 679 680 /** 681 * Returns the project build result summary list. 682 * 683 * @param projectId The project id 684 * @return The build result list 685 * @throws Exception 686 */ 687 List<BuildResultSummary> getBuildResultsForProject( int projectId ) 688 throws Exception; 689 690 /** 691 * Same method but compatible with standard XMLRPC 692 * 693 * @param projectId The project id 694 * @return The build result list as RPC value 695 * @throws Exception 696 */ 697 List<Object> getBuildResultsForProjectRPC( int projectId ) 698 throws Exception; 699 700 /** 701 * Remove the project build result. 702 * 703 * @param br The project build result 704 * @return 0 705 * @throws Exception 706 */ 707 int removeBuildResult( BuildResult br ) 708 throws Exception; 709 710 /** 711 * Same method but compatible with standard XMLRPC 712 * 713 * @param br The project build result 714 * @return 0 715 * @throws Exception 716 */ 717 int removeBuildResultRPC( Map<String, Object> br ) 718 throws Exception; 719 720 /** 721 * Returns the build output. 722 * 723 * @param projectId The project id 724 * @param buildId The build id 725 * @return The build output 726 * @throws Exception 727 */ 728 String getBuildOutput( int projectId, int buildId ) 729 throws Exception; 730 731 // ---------------------------------------------------------------------- 732 // Maven 2.x projects 733 // ---------------------------------------------------------------------- 734 735 /** 736 * Add a maven 2.x project from an url. 737 * 738 * @param url The POM url 739 * @return The result of the action with the list of projects created 740 * @throws Exception 741 */ 742 AddingResult addMavenTwoProject( String url ) 743 throws Exception; 744 745 /** 746 * Same method but compatible with standard XMLRPC 747 * 748 * @param url The POM url 749 * @return The result of the action with the list of projects created as RPC value 750 * @throws Exception 751 */ 752 Map<String, Object> addMavenTwoProjectRPC( String url ) 753 throws Exception; 754 755 /** 756 * Add a maven 2.x project from an url. 757 * 758 * @param url The POM url 759 * @param projectGroupId The id of the group where projects will be stored 760 * @return The result of the action with the list of projects created 761 * @throws Exception 762 */ 763 AddingResult addMavenTwoProject( String url, int projectGroupId ) 764 throws Exception; 765 766 /** 767 * Same method but compatible with standard XMLRPC 768 * 769 * @param url The POM url 770 * @param projectGroupId The id of the group where projects will be stored 771 * @return The result of the action with the list of projects created as RPC value 772 * @throws Exception 773 */ 774 Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId ) 775 throws Exception; 776 777 /** 778 * Add a maven 2.x project from an url. 779 * 780 * @param url The POM url 781 * @param projectGroupId The id of the group where projects will be stored 782 * @return The result of the action with the list of projects created 783 * @throws Exception 784 * @Param checkoutInSingleDirectory Determines whether the project will be stored on a single directory 785 */ 786 AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkoutInSingleDirectory ) 787 throws Exception; 788 789 /** 790 * Same method but compatible with standard XMLRPC 791 * 792 * @param url The POM url 793 * @param projectGroupId The id of the group where projects will be stored 794 * @return The result of the action with the list of projects created as RPC value 795 * @throws Exception 796 * @Param checkoutInSingleDirectory Determines whether the project will be stored on a single directory 797 */ 798 Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId, boolean checkoutInSingleDirectory ) 799 throws Exception; 800 801 /** 802 * Add a maven 2.x multi-module project from a url and add it to Continuum as a single project instead of as 803 * multiple projects (one project per module). To add a multi-module project with its modules as separate Continuum 804 * projects, use ContinuumService#addMavenTwoProject( String url, int projectGroupId, boolean 805 * checkoutInSingleDirectory) instead. 806 * 807 * @param url 808 * @param projectGroupId 809 * @return 810 * @throws Exception 811 */ 812 AddingResult addMavenTwoProjectAsSingleProject( String url, int projectGroupId ) 813 throws Exception; 814 815 /** 816 * Same method but compatible with standard XMLRPC 817 * 818 * @param url 819 * @param projectGroupId 820 * @return 821 * @throws Exception 822 */ 823 Map<String, Object> addMavenTwoProjectAsSingleProjectRPC( String url, int projectGroupId ) 824 throws Exception; 825 826 /** 827 * Add a maven 2.x multi-module project from a url 828 * 829 * @param url The POM url 830 * @param projectGroupId The id of the group where projects will be stored 831 * @param checkProtocol Determines whether the protocol will be checked 832 * @param useCredentialsCache Determines whether user credentials will be cached 833 * @param recursiveProjects Determines whether to load recursive projects 834 * @param checkoutInSingleDirectory Determines whether the project will be stored on a single directory 835 * @return The result of the action with the list of projects created 836 * @throws Exception 837 */ 838 AddingResult addMavenTwoProject( String url, int projectGroupId, boolean checkProtocol, boolean useCredentialsCache, 839 boolean recursiveProjects, boolean checkoutInSingleDirectory ) 840 throws Exception; 841 842 /** 843 * Same method but compatible with standard XMLRPC 844 * 845 * @param url The POM url 846 * @param projectGroupId The id of the group where projects will be stored 847 * @param checkProtocol Determines whether the protocol will be checked 848 * @param useCredentialsCache Determines whether user credentials will be cached 849 * @param recursiveProjects Determines whether to load recursive projects 850 * @param checkoutInSingleDirectory Determines whether the project will be stored on a single directory 851 * @return The result of the action with the list of projects created as RPC value 852 * @throws Exception 853 */ 854 Map<String, Object> addMavenTwoProjectRPC( String url, int projectGroupId, boolean checkProtocol, 855 boolean useCredentialsCache, boolean recursiveProjects, 856 boolean checkoutInSingleDirectory ) 857 throws Exception; 858 859 // ---------------------------------------------------------------------- 860 // Maven 1.x projects 861 // ---------------------------------------------------------------------- 862 863 /** 864 * Add a maven 1.x project from an url. 865 * 866 * @param url The POM url 867 * @param projectGroupId The id of the group where projects will be stored 868 * @return The result of the action with the list of projects created 869 * @throws Exception 870 */ 871 AddingResult addMavenOneProject( String url, int projectGroupId ) 872 throws Exception; 873 874 /** 875 * Same method but compatible with standard XMLRPC 876 * 877 * @param url The POM url 878 * @param projectGroupId The id of the group where projects will be stored 879 * @return The result of the action with the list of projects created as RPC value 880 * @throws Exception 881 */ 882 Map<String, Object> addMavenOneProjectRPC( String url, int projectGroupId ) 883 throws Exception; 884 885 // ---------------------------------------------------------------------- 886 // Maven ANT projects 887 // ---------------------------------------------------------------------- 888 889 /** 890 * Add an ANT project in the specified group. 891 * 892 * @param project The project to add. name, version and scm informations are required 893 * @param projectGroupId The id of the group where projects will be stored 894 * @return The project populated with the id. 895 * @throws Exception 896 */ 897 ProjectSummary addAntProject( ProjectSummary project, int projectGroupId ) 898 throws Exception; 899 900 /** 901 * Same method but compatible with standard XMLRPC 902 * 903 * @param project The project to add. name, version and scm informations are required 904 * @param projectGroupId The id of the group where projects will be stored 905 * @return The project populated with the id as RPC value 906 * @throws Exception 907 */ 908 Map<String, Object> addAntProjectRPC( Map<String, Object> project, int projectGroupId ) 909 throws Exception; 910 911 // ---------------------------------------------------------------------- 912 // Maven Shell projects 913 // ---------------------------------------------------------------------- 914 915 /** 916 * Add an shell project in the specified group. 917 * 918 * @param project The project to add. name, version and scm informations are required 919 * @param projectGroupId The id of the group where projects will be stored 920 * @return The project populated with the id. 921 * @throws Exception 922 */ 923 ProjectSummary addShellProject( ProjectSummary project, int projectGroupId ) 924 throws Exception; 925 926 /** 927 * Same method but compatible with standard XMLRPC 928 * 929 * @param project The project to add. name, version and scm informations are required 930 * @param projectGroupId The id of the group where projects will be stored 931 * @return The project populated with the id as RPC value 932 * @throws Exception 933 */ 934 Map<String, Object> addShellProjectRPC( Map<String, Object> project, int projectGroupId ) 935 throws Exception; 936 937 // ---------------------------------------------------------------------- 938 // ADMIN TASKS 939 // ---------------------------------------------------------------------- 940 941 // ---------------------------------------------------------------------- 942 // Schedules 943 // ---------------------------------------------------------------------- 944 945 /** 946 * Return the schedules list. 947 * 948 * @return The schedule list. 949 * @throws Exception 950 */ 951 List<Schedule> getSchedules() 952 throws Exception; 953 954 /** 955 * Same method but compatible with standard XMLRPC 956 * 957 * @return The schedule list as RPC value. 958 * @throws Exception 959 */ 960 List<Object> getSchedulesRPC() 961 throws Exception; 962 963 /** 964 * Return the schedule defined by this id. 965 * 966 * @param scheduleId The schedule id 967 * @return The schedule. 968 * @throws Exception 969 */ 970 Schedule getSchedule( int scheduleId ) 971 throws Exception; 972 973 /** 974 * Same method but compatible with standard XMLRPC 975 * 976 * @param scheduleId The schedule id 977 * @return The schedule as RPC value. 978 * @throws Exception 979 */ 980 Map<String, Object> getScheduleRPC( int scheduleId ) 981 throws Exception; 982 983 /** 984 * Add the schedule. 985 * 986 * @param schedule The schedule 987 * @return The schedule. 988 * @throws Exception 989 */ 990 Schedule addSchedule( Schedule schedule ) 991 throws Exception; 992 993 /** 994 * Same method but compatible with standard XMLRPC 995 * 996 * @param schedule The schedule 997 * @return The schedule as RPC value. 998 * @throws Exception 999 */ 1000 Map<String, Object> addScheduleRPC( Map<String, Object> schedule ) 1001 throws Exception; 1002 1003 /** 1004 * Update the schedule. 1005 * 1006 * @param schedule The schedule 1007 * @return The schedule. 1008 * @throws Exception 1009 */ 1010 Schedule updateSchedule( Schedule schedule ) 1011 throws Exception; 1012 1013 /** 1014 * Same method but compatible with standard XMLRPC 1015 * 1016 * @param schedule The schedule 1017 * @return The schedule as RPC value. 1018 * @throws Exception 1019 */ 1020 Map<String, Object> updateScheduleRPC( Map<String, Object> schedule ) 1021 throws Exception; 1022 1023 // ---------------------------------------------------------------------- 1024 // Profiles 1025 // ---------------------------------------------------------------------- 1026 1027 /** 1028 * Return the profiles list. 1029 * 1030 * @return The profiles list. 1031 * @throws Exception 1032 */ 1033 List<Profile> getProfiles() 1034 throws Exception; 1035 1036 /** 1037 * Same method but compatible with standard XMLRPC 1038 * 1039 * @return The profiles list as RPC value. 1040 * @throws Exception 1041 */ 1042 List<Object> getProfilesRPC() 1043 throws Exception; 1044 1045 /** 1046 * Return the profile defined by this id. 1047 * 1048 * @param profileId The profile id 1049 * @return The profile. 1050 * @throws Exception 1051 */ 1052 Profile getProfile( int profileId ) 1053 throws Exception; 1054 1055 /** 1056 * Same method but compatible with standard XMLRPC 1057 * 1058 * @param profileId The profile id 1059 * @return The profile. 1060 * @throws Exception 1061 */ 1062 Map<String, Object> getProfileRPC( int profileId ) 1063 throws Exception; 1064 1065 Profile getProfileWithName( String profileName ) 1066 throws Exception; 1067 1068 Map<String, Object> getProfileWithNameRPC( String profileName ) 1069 throws Exception; 1070 1071 Profile addProfile( Profile profile ) 1072 throws Exception; 1073 1074 int updateProfile( Profile profile ) 1075 throws Exception; 1076 1077 int deleteProfile( int profileId ) 1078 throws Exception; 1079 1080 Map<String, Object> addProfileRPC( Map<String, Object> profile ) 1081 throws Exception; 1082 1083 int updateProfileRPC( Map<String, Object> profile ) 1084 throws Exception; 1085 1086 // ---------------------------------------------------------------------- 1087 // Installations 1088 // ---------------------------------------------------------------------- 1089 1090 /** 1091 * Return the installations list. 1092 * 1093 * @return The installations list. 1094 * @throws Exception 1095 */ 1096 List<Installation> getInstallations() 1097 throws Exception; 1098 1099 /** 1100 * Same method but compatible with standard XMLRPC 1101 * 1102 * @return The installations list. 1103 * @throws Exception 1104 */ 1105 List<Object> getInstallationsRPC() 1106 throws Exception; 1107 1108 /** 1109 * Return the installation defined by this id. 1110 * 1111 * @param installationId The installation id 1112 * @return The installation. 1113 * @throws Exception 1114 */ 1115 Installation getInstallation( int installationId ) 1116 throws Exception; 1117 1118 /** 1119 * Same method but compatible with standard XMLRPC 1120 * 1121 * @param installationId The installation id 1122 * @return The installation. 1123 * @throws Exception 1124 */ 1125 Map<String, Object> getInstallationRPC( int installationId ) 1126 throws Exception; 1127 1128 /** 1129 * Return the installation defined by this name 1130 * 1131 * @param installationName The installation name 1132 * @return The installation 1133 * @throws Exception 1134 */ 1135 Installation getInstallation( String installationName ) 1136 throws Exception; 1137 1138 /** 1139 * Same method but compatible with standard XMLRPC 1140 * 1141 * @param installationName The installation name 1142 * @return The installation 1143 * @throws Exception 1144 */ 1145 Map<String, Object> getInstallationRPC( String installationName ) 1146 throws Exception; 1147 1148 /** 1149 * Return the installations list defined by this URL. 1150 * 1151 * @param url The build agent URL 1152 * @return The installations list. 1153 * @throws Exception 1154 */ 1155 List<Installation> getBuildAgentInstallations( String url ) 1156 throws Exception; 1157 1158 /** 1159 * Same method but compatible with standard XMLRPC 1160 * 1161 * @param url The build agent URL 1162 * @return The installations list. 1163 * @throws Exception 1164 */ 1165 List<Object> getBuildAgentInstallationsRPC( String url ) 1166 throws Exception; 1167 1168 Installation addInstallation( Installation installation ) 1169 throws Exception; 1170 1171 int updateInstallation( Installation installation ) 1172 throws Exception; 1173 1174 int deleteInstallation( int installationId ) 1175 throws Exception; 1176 1177 Map<String, Object> addInstallationRPC( Map<String, Object> installation ) 1178 throws Exception; 1179 1180 int updateInstallationRPC( Map<String, Object> installation ) 1181 throws Exception; 1182 1183 // ---------------------------------------------------------------------- 1184 // SystemConfiguration 1185 // ---------------------------------------------------------------------- 1186 1187 SystemConfiguration getSystemConfiguration() 1188 throws Exception; 1189 1190 Map<String, Object> getSystemConfigurationRPC() 1191 throws Exception; 1192 1193 // ---------------------------------------------------------------------- 1194 // Queue 1195 // ---------------------------------------------------------------------- 1196 1197 /** 1198 * Return true if the project is in prepare build queue 1199 * 1200 * @param projectId The project id 1201 * @throws ContinuumException 1202 */ 1203 boolean isProjectInPrepareBuildQueue( int projectId ) 1204 throws Exception; 1205 1206 /** 1207 * Return true if the project is in prepare build queue 1208 * 1209 * @param projectId The project id 1210 * @param buildDefinitionId The build definition id 1211 * @throws ContinuumException 1212 */ 1213 boolean isProjectInPrepareBuildQueue( int projectId, int buildDefinitionId ) 1214 throws Exception; 1215 1216 /** 1217 * Return true if the project is in building queue. 1218 * 1219 * @param projectId The project id 1220 * @throws ContinuumException 1221 */ 1222 boolean isProjectInBuildingQueue( int projectId ) 1223 throws Exception; 1224 1225 /** 1226 * Return true if the project is in building queue. 1227 * 1228 * @param projectId The project id 1229 * @param buildDefinitionId The build definition id 1230 * @throws ContinuumException 1231 */ 1232 boolean isProjectInBuildingQueue( int projectId, int buildDefinitionId ) 1233 throws Exception; 1234 1235 /** 1236 * Return true if the project is currently preparing build 1237 * 1238 * @param projectId The project id 1239 * @return 1240 * @throws Exception 1241 */ 1242 boolean isProjectCurrentlyPreparingBuild( int projectId ) 1243 throws Exception; 1244 1245 /** 1246 * Return true if the project is currently preparing build 1247 * 1248 * @param projectId The project id 1249 * @param buildDefinitionId The build definition id 1250 * @return 1251 * @throws Exception 1252 */ 1253 boolean isProjectCurrentlyPreparingBuild( int projectId, int buildDefinitionId ) 1254 throws Exception; 1255 1256 /** 1257 * Return true if the project is currently building 1258 * 1259 * @param projectId The project id 1260 * @return 1261 * @throws Exception 1262 */ 1263 boolean isProjectCurrentlyBuilding( int projectId ) 1264 throws Exception; 1265 1266 /** 1267 * Return true if the project is currently building 1268 * 1269 * @param projectId The project id 1270 * @param buildDefinitionId The build definition id 1271 * @return 1272 * @throws Exception 1273 */ 1274 boolean isProjectCurrentlyBuilding( int projectId, int buildDefinitionId ) 1275 throws Exception; 1276 1277 /** 1278 * Return projects building queue. 1279 * 1280 * @throws ContinuumException 1281 */ 1282 public List<BuildProjectTask> getProjectsInBuildQueue() 1283 throws Exception; 1284 1285 /** 1286 * Remove projects from build queue 1287 * 1288 * @param projectsId project id to be removed from the building queue 1289 * @return 1290 * @throws Exception 1291 */ 1292 int removeProjectsFromBuildingQueue( int[] projectsId ) 1293 throws Exception; 1294 1295 /** 1296 * Cancel the current project build 1297 * 1298 * @return 1299 * @throws Exception 1300 */ 1301 boolean cancelCurrentBuild() 1302 throws Exception; 1303 1304 /** 1305 * Cancel a project build 1306 * 1307 * @param projectId the project id 1308 * @param buildDefinitionId the build definition id 1309 * @return 1310 * @throws Exception 1311 */ 1312 boolean cancelBuild( int projectId, int buildDefinitionId ) 1313 throws Exception; 1314 1315 // ---------------------------------------------------------------------- 1316 // TODO:Users 1317 // ---------------------------------------------------------------------- 1318 1319 // ---------------------------------------------------------------------- 1320 // Utils 1321 // ---------------------------------------------------------------------- 1322 1323 boolean ping() 1324 throws Exception; 1325 1326 // ---------------------------------------------------------------------- 1327 // Local Repository 1328 // ---------------------------------------------------------------------- 1329 1330 /** 1331 * Add a local repository 1332 * 1333 * @param repository the local repository to add 1334 * @return 1335 * @throws Exception 1336 */ 1337 LocalRepository addLocalRepository( LocalRepository repository ) 1338 throws Exception; 1339 1340 /** 1341 * Same method but compatible with the standard XMLRPC 1342 * 1343 * @param repository the local repository to add 1344 * @return 1345 * @throws Exception 1346 */ 1347 Map<String, Object> addLocalRepositoryRPC( Map<String, Object> repository ) 1348 throws Exception; 1349 1350 /** 1351 * Update the local repository 1352 * 1353 * @param repository the local repository to update 1354 * @return 1355 * @throws Exception 1356 */ 1357 int updateLocalRepository( LocalRepository repository ) 1358 throws Exception; 1359 1360 /** 1361 * Same method but compatible with the standard XMLRPC 1362 * 1363 * @param repository the local repository to update 1364 * @return 1365 * @throws Exception 1366 */ 1367 int updateLocalRepositoryRPC( Map<String, Object> repository ) 1368 throws Exception; 1369 1370 /** 1371 * Remove the local repository 1372 * 1373 * @param repositoryId 1374 * @return 1375 * @throws Exception 1376 */ 1377 int removeLocalRepository( int repositoryId ) 1378 throws Exception; 1379 1380 /** 1381 * Returns the local repository 1382 * 1383 * @param repositoryId the local repository id 1384 * @return 1385 * @throws Exception 1386 */ 1387 LocalRepository getLocalRepository( int repositoryId ) 1388 throws Exception; 1389 1390 /** 1391 * Same method but compatible with the standard XMLRPC 1392 * 1393 * @param repositoryId 1394 * @return 1395 * @throws Exception 1396 */ 1397 Map<String, Object> getLocalRepositoryRPC( int repositoryId ) 1398 throws Exception; 1399 1400 /** 1401 * Returns all local repositories 1402 * 1403 * @return 1404 * @throws Exception 1405 */ 1406 List<LocalRepository> getAllLocalRepositories() 1407 throws Exception; 1408 1409 /** 1410 * Same method but compatible with the standard XMLRPC 1411 * 1412 * @return 1413 * @throws Exception 1414 */ 1415 List<Object> getAllLocalRepositoriesRPC() 1416 throws Exception; 1417 1418 // ---------------------------------------------------------------------- 1419 // Purging 1420 // ---------------------------------------------------------------------- 1421 1422 /** 1423 * Add a repository purge configuration 1424 * 1425 * @param repoPurge the repository purge configuration 1426 * @return 1427 * @throws Exception 1428 */ 1429 RepositoryPurgeConfiguration addRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge ) 1430 throws Exception; 1431 1432 /** 1433 * Same method but compatible with the standard XMLRPC 1434 * 1435 * @param repoPurge the repository purge configuration 1436 * @return 1437 * @throws Exception 1438 */ 1439 Map<String, Object> addRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge ) 1440 throws Exception; 1441 1442 /** 1443 * Update the repository purge configuration 1444 * 1445 * @param repoPurge the repository purge configuration 1446 * @return 1447 * @throws Exception 1448 */ 1449 int updateRepositoryPurgeConfiguration( RepositoryPurgeConfiguration repoPurge ) 1450 throws Exception; 1451 1452 /** 1453 * Same method but compatible with the standard XMLRPC 1454 * 1455 * @param repoPurge the repository purge configuration 1456 * @return 1457 * @throws Exception 1458 */ 1459 int updateRepositoryPurgeConfigurationRPC( Map<String, Object> repoPurge ) 1460 throws Exception; 1461 1462 /** 1463 * Remove repository purge configuration 1464 * 1465 * @param repoPurgeId the repository purge configuration id 1466 * @return 1467 * @throws Exception 1468 */ 1469 int removeRepositoryPurgeConfiguration( int repoPurgeId ) 1470 throws Exception; 1471 1472 /** 1473 * Returns the repository purge configuration 1474 * 1475 * @param purgeConfigId the repository purge configuration id 1476 * @return the repository purge configuration 1477 * @throws Exception 1478 */ 1479 RepositoryPurgeConfiguration getRepositoryPurgeConfiguration( int repoPurgeId ) 1480 throws Exception; 1481 1482 /** 1483 * Same method but compatible with standard XMLRPC 1484 * 1485 * @param purgeConfigId the repository purge configuration id 1486 * @return the repository purge configuration 1487 * @throws Exception 1488 */ 1489 Map<String, Object> getRepositoryPurgeConfigurationRPC( int purgeConfigId ) 1490 throws Exception; 1491 1492 /** 1493 * Returns repository purge configurations list 1494 * 1495 * @return list of repository purge configurations 1496 * @throws Exception 1497 */ 1498 List<RepositoryPurgeConfiguration> getAllRepositoryPurgeConfigurations() 1499 throws Exception; 1500 1501 /** 1502 * Same method but compatible with standard XMLRPC 1503 * 1504 * @return list of repository purge configurations 1505 * @throws Exception 1506 */ 1507 List<Object> getAllRepositoryPurgeConfigurationsRPC() 1508 throws Exception; 1509 1510 /** 1511 * Add a directory purge configuration 1512 * 1513 * @param dirPurge the directory purge configuration 1514 * @return 1515 * @throws Exception 1516 */ 1517 DirectoryPurgeConfiguration addDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge ) 1518 throws Exception; 1519 1520 /** 1521 * Same method but compatible with the standard XMLRPC 1522 * 1523 * @param dirPurge the directory purge configuration 1524 * @return 1525 * @throws Exception 1526 */ 1527 Map<String, Object> addDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge ) 1528 throws Exception; 1529 1530 /** 1531 * Update the directory purge configuration 1532 * 1533 * @param dirPurge the directory purge configuration 1534 * @return 1535 * @throws Exception 1536 */ 1537 int updateDirectoryPurgeConfiguration( DirectoryPurgeConfiguration dirPurge ) 1538 throws Exception; 1539 1540 /** 1541 * Same method but compatible with the standard XMLRPC 1542 * 1543 * @param dirPurge the directory purge configuration 1544 * @return 1545 * @throws Exception 1546 */ 1547 int updateDirectoryPurgeConfigurationRPC( Map<String, Object> dirPurge ) 1548 throws Exception; 1549 1550 /** 1551 * Removes the directory purge configuration 1552 * 1553 * @param dirPurgeId the directory purge configuration id 1554 * @return 1555 * @throws Exception 1556 */ 1557 int removeDirectoryPurgeConfiguration( int dirPurgeId ) 1558 throws Exception; 1559 1560 /** 1561 * Returns the directory purge configuration 1562 * 1563 * @param purgeConfigId the directory purge configuration id 1564 * @return the directory purge configuration 1565 * @throws Exception 1566 */ 1567 DirectoryPurgeConfiguration getDirectoryPurgeConfiguration( int purgeConfigId ) 1568 throws Exception; 1569 1570 /** 1571 * Same method but compatible with standard XMLRPC 1572 * 1573 * @param purgeConfigId the directory purge configuration id 1574 * @return the directory purge configuration 1575 * @throws Exception 1576 */ 1577 Map<String, Object> getDirectoryPurgeConfigurationRPC( int purgeConfigId ) 1578 throws Exception; 1579 1580 /** 1581 * Returns directory purge configurations list 1582 * 1583 * @return list of directory purge configurations 1584 * @throws Exception 1585 */ 1586 List<DirectoryPurgeConfiguration> getAllDirectoryPurgeConfigurations() 1587 throws Exception; 1588 1589 /** 1590 * Same method but compatible with standard XMLRPC 1591 * 1592 * @return list of directory purge configurations 1593 * @throws Exception 1594 */ 1595 List<Object> getAllDirectoryPurgeConfigurationsRPC() 1596 throws Exception; 1597 1598 int purgeLocalRepository( int repoPurgeId ) 1599 throws Exception; 1600 1601 int purgeDirectory( int dirPurgeId ) 1602 throws Exception; 1603 1604 // ---------------------------------------------------------------------- 1605 // Release Results 1606 // ---------------------------------------------------------------------- 1607 1608 /** 1609 * Returns the release result. 1610 * 1611 * @param releaseId The release id 1612 * @return The release result 1613 * @throws Exception 1614 */ 1615 ContinuumReleaseResult getReleaseResult( int releaseId ) 1616 throws Exception; 1617 1618 /** 1619 * Same method but compatible with standard XMLRPC 1620 * 1621 * @param releaseId The release id 1622 * @return The release result as RPC value 1623 * @throws Exception 1624 */ 1625 Map<String, Object> getReleaseResultRPC( int releaseId ) 1626 throws Exception; 1627 1628 /** 1629 * Returns the project group release result list. 1630 * 1631 * @param projectGroupId The project group id 1632 * @return The release result list 1633 * @throws Exception 1634 */ 1635 List<ContinuumReleaseResult> getReleaseResultsForProjectGroup( int projectGroupId ) 1636 throws Exception; 1637 1638 /** 1639 * Same method but compatible with standard XMLRPC 1640 * 1641 * @param projectGroupId The project group id 1642 * @return The release result list as RPC value 1643 * @throws Exception 1644 */ 1645 List<Object> getReleaseResultsForProjectGroupRPC( int projectGroupId ) 1646 throws Exception; 1647 1648 /** 1649 * Remove the project release result. 1650 * 1651 * @param releaseResult The project release result 1652 * @return 0 1653 * @throws Exception 1654 */ 1655 int removeReleaseResult( ContinuumReleaseResult releaseResult ) 1656 throws Exception; 1657 1658 /** 1659 * Same method but compatible with standard XMLRPC 1660 * 1661 * @param rr The project release result 1662 * @return 0 1663 * @throws Exception 1664 */ 1665 int removeReleaseResultRPC( Map<String, Object> rr ) 1666 throws Exception; 1667 1668 /** 1669 * Returns the release output. 1670 * 1671 * @param releaseId The release id 1672 * @return The release output 1673 * @throws Exception 1674 */ 1675 String getReleaseOutput( int releaseId ) 1676 throws Exception; 1677 1678 /** 1679 * Release prepare a project 1680 * 1681 * @param projectId 1682 * @param releaseProperties 1683 * @param releaseVersions 1684 * @param developmentVersions 1685 * @param environments 1686 * @param username 1687 * @return The release id 1688 * @throws Exception 1689 */ 1690 String releasePrepare( int projectId, Properties releaseProperties, Map<String, String> releaseVersions, 1691 Map<String, String> developmentVersions, Map<String, String> environments, String username ) 1692 throws Exception; 1693 1694 /** 1695 * Release perform a project 1696 * 1697 * @param projectId 1698 * @param releaseId 1699 * @param goals 1700 * @param arguments 1701 * @param useReleaseProfile 1702 * @param repositoryName 1703 * @param username 1704 * @return 1705 * @throws Exception 1706 */ 1707 int releasePerform( int projectId, String releaseId, String goals, String arguments, boolean useReleaseProfile, 1708 String repositoryName, String username ) 1709 throws Exception; 1710 1711 /** 1712 * Get release listener 1713 * 1714 * @param projectId 1715 * @param releaseId 1716 * @return 1717 * @throws Exception 1718 */ 1719 ReleaseListenerSummary getListener( int projectId, String releaseId ) 1720 throws Exception; 1721 1722 /** 1723 * Cleanup the release 1724 * 1725 * @param projectId 1726 * @param releaseId 1727 * @return 1728 * @throws Exception 1729 */ 1730 int releaseCleanup( int projectId, String releaseId ) 1731 throws Exception; 1732 1733 /** 1734 * Cleanup the release 1735 * 1736 * @param projectId 1737 * @param releaseId 1738 * @param releaseType 1739 * @return 1740 * @throws Exception 1741 */ 1742 int releaseCleanup( int projectId, String releaseId, String releaseType ) 1743 throws Exception; 1744 1745 /** 1746 * Rollback a release 1747 * 1748 * @param projectId 1749 * @param releaseId 1750 * @return 1751 * @throws Exception 1752 */ 1753 int releaseRollback( int projectId, String releaseId ) 1754 throws Exception; 1755 1756 /** 1757 * Get release plugin parameters 1758 * 1759 * @param projectId 1760 * @return 1761 */ 1762 Map<String, Object> getReleasePluginParameters( int projectId ) 1763 throws Exception; 1764 1765 List<Map<String, String>> getProjectReleaseAndDevelopmentVersions( int projectId, String pomFilename, 1766 boolean autoVersionSubmodules ) 1767 throws Exception; 1768 1769 /** 1770 * Add/Register build agent to Continuum Master 1771 * 1772 * @return 1773 * @throws Exception 1774 */ 1775 BuildAgentConfiguration addBuildAgent( BuildAgentConfiguration buildAgentConfiguration ) 1776 throws Exception; 1777 1778 /** 1779 * Same method but compatible with standard XMLRPC 1780 * 1781 * @return 1782 * @throws Exception 1783 */ 1784 Map<String, Object> addBuildAgentRPC( Map<String, Object> buildAgentConfiguration ) 1785 throws Exception; 1786 1787 /** 1788 * Get build agent in Continuum Master 1789 * 1790 * @param url - build agent URL 1791 * @return 1792 */ 1793 BuildAgentConfiguration getBuildAgent( String url ); 1794 1795 /** 1796 * Get the url of the build agent that is processing the project 1797 * 1798 * @param projectId project Id 1799 * @param buildDefinitionId build definition Id 1800 * @return build agent url 1801 */ 1802 String getBuildAgentUrl( int projectId, int buildDefinition ) 1803 throws Exception; 1804 1805 /** 1806 * Same method but compatible with standard XMLRPC 1807 * 1808 * @param url - build agent URL 1809 * @return 1810 */ 1811 Map<String, Object> getBuildAgentRPC( String url ); 1812 1813 /** 1814 * Update build agent in Continuum Master 1815 * 1816 * @return 1817 * @throws Exception 1818 */ 1819 BuildAgentConfiguration updateBuildAgent( BuildAgentConfiguration buildAgentConfiguration ) 1820 throws Exception; 1821 1822 /** 1823 * Same method but compatible with standard XMLRPC 1824 * 1825 * @return 1826 * @throws Exception 1827 */ 1828 Map<String, Object> updateBuildAgentRPC( Map<String, Object> buildAgentConfiguration ) 1829 throws Exception; 1830 1831 /** 1832 * remove build agent in Continuum Master 1833 * 1834 * @param url - build agent URL 1835 * @return Exception 1836 */ 1837 boolean removeBuildAgent( String url ) 1838 throws Exception; 1839 1840 /** 1841 * List all build agent in Continuum Master 1842 * 1843 * @return 1844 */ 1845 List<BuildAgentConfiguration> getAllBuildAgents(); 1846 1847 /** 1848 * Same method but compatible with standard XMLRPC 1849 * 1850 * @return 1851 */ 1852 List<Object> getAllBuildAgentsRPC(); 1853 1854 /** 1855 * Retrieve all enabled build agents with their available installations 1856 * 1857 * @return 1858 * @throws Exception 1859 */ 1860 List<BuildAgentConfiguration> getBuildAgentsWithInstallations() 1861 throws Exception; 1862 1863 /** 1864 * Same method but compatible with standard XMLRPC 1865 * 1866 * @return 1867 * @throws Exception 1868 */ 1869 List<Object> getBuildAgentsWithInstallationsRPC() 1870 throws Exception; 1871 1872 boolean pingBuildAgent( String buildAgentUrl ) 1873 throws Exception; 1874 1875 BuildAgentGroupConfiguration addBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup ) 1876 throws Exception; 1877 1878 Map<String, Object> addBuildAgentGroupRPC( Map<String, Object> buildAgentGroup ) 1879 throws Exception; 1880 1881 BuildAgentGroupConfiguration getBuildAgentGroup( String name ); 1882 1883 Map<String, Object> getBuildAgentGroupRPC( String name ); 1884 1885 BuildAgentGroupConfiguration updateBuildAgentGroup( BuildAgentGroupConfiguration buildAgentGroup ) 1886 throws Exception; 1887 1888 Map<String, Object> updateBuildAgentGroupRPC( Map<String, Object> buildAgentGroup ) 1889 throws Exception; 1890 1891 int removeBuildAgentGroup( String name ) 1892 throws Exception; 1893 }