Author : Srinivasan Chikkala
Date : 10/16/06
Draft Version :  0.1

JBI  Component Development Tools ( JBICDT ) User View

This document describes the usecases and the userview that will be supported for JBI Components Development Tools (JBICDT).

JBICDT contains GUI based tools that provide integrated development environment for developing Service Engines and Binding Components. These tools are based on Netbeans IDE and provides the standard Netbeans IDE user experience in developing JBI Components using Netbeans IDE.

Installation

JBICDT i mainly targeted to run on Netbeans IDE 5.5 or above. The minimum version of the Netbeans IDE that will be supported for JBICDT is 5.5. JBICDT will be installed on the Netbeans IDE as a set of Netbeans modules.  JBICDT modules will be part of the Netbeans Enterprise Pack 5.6 and will be added to soa1? cluster of the enterprise pack tools.

Users

Target users are the JBI Component developers who develop Service Engines and Binding Components using JBI APIs and SPIs. These users can use JBICDT along with the standard java development tools
provided in the IDE.

Usecases

The following usecases will be supported in JBICDT from the set of requirements from

Usecase #
 Usecase
 Comments
1
Create Component project for Service Engine (SE) Development
2
Create Component project for Binding Component (BC) Development
3
Create sample component code for SE  
4
Create sample component code for BC
5
View Component ( SE or BC )  artifacts
6
Customize Component Project
6.1
Change Component description

6.1.1
Change component name in JBI.xml and build scripts

6.1.2
Change component description in JBI.xml

6.2
Add/remove libraries

6.2.1
Add/remove external jar files and update JBI.xml

6.2.2
Add/remove dependent project jar files and update JBI.xml

6.3
Change Installation options

6.3.1
Select target JBI server

6.3.2
Select component start after installation

6.4
Change test options

6.4.1
Build and deploy test SA before junit test runs

7
Compile component code
7.1
Include JBI jar as library in compile classpath

7.2
Include exteranl jar or dependent project jar files in compile classpath

8
Package component code
8.1
Package external jars and dependent project jars in the component zip file

9
Install component
9.1
Select target JBI server for installation

9.2
Install and start ( optional ) component

10
Test component

10.1
(optional ) Build and deploy testSA before running junit test

11
Provide help on JBI APIs in Java Editor
11.1
Code complete JBI APIs  in Java editor window

11.2
Bring up inline help window for JBI APIs in Java editor window

12
Schema validate jbi.xml in xml text editor







User Workflow

A standard Netbeans IDE user interactions will be used in JBICDT for JBI Component development activities by providing Projects, Actions, Wizards, Nodes and Editors for creating and manipulating JBI Service Engine( SE) or Binding Component ( BC ) artifacts. A Developer would create, edit, build, install and test the JBI components ( SE or BC) using JBICDT. For developing SE or BC, JBI developer starts with creating or opening an already created project corresponding to SE or BC and view/edit/build/test component artifacts in the project environment. The component ( SE or BC ) project will have ant based build scripts for compile, package, install and test the component, a explorer view for navigating to the JBI artifacts, set of actions to perform various tasks like edit, build, install and test etc.

The following are the common steps that user will perform in component development lifecycle using JBICDT
  1. Create a project  - select the project wizard using the project templates dialog and enter required data for creating the project and the set of component artifacts ( jbi.xml and the sample java code ) for  SE or BC project.
  2. Edit the java code for the component -  navigates to the java code under source packages in the project view and bring up the java editor for add/modify the java code. User can use inline help and code completion for the JBI APIs used in the code.
  3. Add/remove java libraries - add/remove jar files required for the component which can be external to the IDE or produced by the dependent projects in the IDE using project customizer.
  4. Build component  - select project standard actions to clean, compile and package the component code into a zip file for installation to JBI Platform.
  5. Add test code -  create a junit test cases in the Test source folder that can act as a service consumer or service provider to send/receive messages from the component. Some times, user might want to create a test service assembly to deploy it to the components in the jbi server as part of the test which can be deployed by the project test action if configured through project customizer to deploy the test service assembly.
  6. Install component  -  select project action that can install the component to the JBI Platform.
  7. Test component. - select the project action from the project node to run the unit tests with optional test service assembly deployment to test the installed component.
  8. Debug component  - starts the appserver in debug mode and then attach the appserver debugger to the IDE so that the component code can be debugged
  9. Control component lifecycle ( start, stop or shutdown ) - during the test/debug cycle, user changes the state of the component
  10. Uninstall component  - can uninstall component from the target server for re-installing the modified component from the IDE.

Service Engine Project Wizard

<Service Engine Wizard Image>
Service Engine Wizard

Binding Component Project Wizard

<Binding Component Wizard Image>
Binding Component Project Wizard

Project View

<Project Explorer View Image>

Project View

Project Actions

<Project Actions popup menu Image>
Project Actions

Project Customizer

<Project customizer Image>