Red Hat JBoss Fuse Tooling is an Eclipse-based IDE for creating and testing small- and large-scale integration applications. Its key features are a graphical routing editor, a full-featured Camel debugger for debugging locally running routing contexts, and an integrated testing platform that uses JMX to communicate with the containers in a small-scale test environment.
The tooling provides two main perspectives. You use Fuse Integration Perspective to design, test and publish your Fuse Integration projects. You use Debug Perspective to debug your routing context files.
Using Red Hat JBoss Fuse Tooling simplifies and streamlines the process of developing integration applications by providing tooling that is specifically designed to work with:
- Red Hat JBoss Fuse
- Red Hat JBoss EAP
- Red Hat JBoss A-MQ
- Apache Camel
- Apache CXF
- Apache Karaf
![[Note]](imagesdb/note.png) | Note |
|---|---|
You can also develop Fuse projects using Maven (for details, see Developing and Deploying Applications). |
Using the Red Hat JBoss Fuse Tooling streamlines the process at all stages of application development:
Create a Maven project for your application.
The tooling loads all of the relevant Maven archetypes for creating integration projects using the Red Hat supported Apache projects.
Add new pieces of logic and functionality to an application.
The tooling has a wizard for creating Apache Camel context files.
Edit the integration logic.
The tooling has a visual route editor that makes editing Apache Camel routes as easy as dragging and dropping routing components.
Debug your local Camel context.
The tooling includes a full-featured Camel debugger for debugging locally running Camel contexts.
Test the application.
The tooling includes testing tools that provide the full gamut of testing capabilities including:
- Creating and using JUnit test cases on Apache Camel routes
- Using JMX to analyze running components
- Tracing messages through Apache Camel routes
Deploy the application.
The tooling can deploy applications to a number of containers.
See the Fuse Tooling tutorials for step-by-step instructions on:
- Creating a Route
- Running a Route
- Adding a Content-Based Router
- Adding Another Route to the CBR Routing Context
- Debugging a Routing Context
- Tracing a Message Through a Route
- Testing a Route with JUnit
- Publishing a Fuse Project to Red Hat JBoss Fuse
The Fuse Integration perspective, shown in Figure 6, “Fuse Integration perspective”, provides access to all of the tooling for designing, monitoring, testing, and publishing your integration application.
| Note |
|---|---|
You can open the Fuse Integration perspective in two ways:
|
The Fuse Integration perspective consists of nine main areas:
Project Explorer view — displays all projects known to the tooling. You can view all artifacts that make up each project. The Project Explorer view also displays all routing context
.xml. files for a project under itsCamel Contextsnode. This enables you to find and open a routing context file included in a project. Under each routing context.xmlfile, the Project Explorer view displays all routes defined within the context. For multiroute contexts, this lets you focus on a specific route on the canvas.
The route editor — The route editor provides the main design-time tooling and consists of three tabs:
Design — Displays a large grid area on which routes are constructed and a palette from which Enterprise Integration Patterns (EIPs) and Camel components are selected and then connected on the canvas to form routes.
The canvas is the route editor’s workbench and where you do most of your work. It displays a graphical representation of one or more routes, which are made up of connected EIPs and Camel components (called nodes once they are placed on the canvas).
Selecting a node on the canvas populates the Properties view with the properties that apply to the selected node, so you can edit them.
The Palette contains all of the patterns and Camel components needed to construct a route and groups them according to function — Components, Routing, Control Flow, Transformation, and Miscellaneous.
Source — Displays the .xml configuration corresponding to the routes constructed on the route editor’s canvas.
You can edit the routing context in the Source tab as well as in the Design tab.
Configurations — Provides an easy way to add shared configuration (global endpoints, data formats, beans) to a multiroute, routing context. For details see Adding global endpoints, data formats or beans.
- Properties view — displays the properties of the node selected on the canvas.
JMX Navigator view — lists the JMX servers and the infrastructure they monitor. It enables you to browse JMX servers and the pocesses they are monitoring. It also identifies instances of Red Hat processes.
The JMX Navigator view drives all monitoring and testing activities in the Fuse Integration perspective. It determines which routes are displayed in the Diagram View, the Properties view, and the Messages View. It is also provides menu commands for activating route tracing, adding and deleting JMS destinations, and starting and suspending routes. It is also the target for dragging and dropping messages onto a route.
By default, the JMX Navigator view shows all Java processes that are running on your local machine. You can add JMX servers as needed to view infrastructure on other machines.
Diagram View — displays a graphical tree representing the node selected in the JMX Navigator view. When you select a process, server, endpoint, or other node, the Diagram View shows the selected node as the root with branches down to its children and grandchildren.
When you select a broker, the Diagram View displays up to three children: connections, topics, and queues. It also shows configured connections and destinations as grandchildren.
When you select a route, the Diagram View displays all nodes in the route and shows the different paths that messages can take through the route. It also displays timing metrics for each processing step in the route when route tracing is enabled.
Messages View — lists the messages that have passed through the selected JMS destination or through Apache Camel endpoints when route tracing is enabled.
When a JMS destination is selected in the JMX Navigator view, the view lists all messages that are at the destination.
When route tracing is enabled, the Messages View lists all messages that passed through the nodes in the route since tracing started. You can configure the Messages View to display only the data in which you are interested and in your preferred sequence.
When a message trace in the Messages View is selected, its details (message body and all message headers) appear in the Properties view. In the Diagram View, the step in the route associated with the selected message trace is highlighted.
- Servers view — displays a list of servers managed by the tooling. It displays their runtime status and provides controls for adding, starting and stopping them and for publishing projects to them.
- Terminal view — displays the command console of the connected container. You can control the container by entering commands in the Terminal view.
- Console view — displays the console output for recently executed actions.
The Debug perspective, shown in Figure 7, “Debug perspective”, provides access to all of the Camel debugger’s functions. It contains all of the views used to monitor and debug a running routing context.
Debug view
For the running routing context, the Debug view displays the debug stack.
You can switch between breakpoints within the same message flow, listed under the
Camel Context at service:jmx:rmi://jndi/rmi://localhost:1099/jmxrmi/camelentry, to review and compare variable values in the Variables view.Messages flows are identified by their unique breadcrumb ID, and the breadcrumb ID of each subsequent message flow is incremented by 2. For example, in Figure 7, “Debug perspective”, the breadcrumb ID for the first message flow is
ID-janemurpheysmbp-home-54620-1470949590275-0-1, so the breadcrumbID for the second message flow would beID-janemurpheysmbp-home-54620-1470949590275-0-3.Variables view
For each node in the routing context that has a breakpoint set, the Variables view displays the value of the available variables when the breakpoint is hit. Each variable who’s value changed since the preceding breakpoint is highlighted in yellow.
You can change the value of editable variables to check whether such changes produce the expected results and to test the robustness of your routing context.
You can also add variables to the watch list, so you can quickly and easily see whether their values change as expected at the expected point in the message flow.
Breakpoints view
Displays a list of the breakpoints set in the routing context, and shows whether they are enabled or disabled. You can enable and disable individual breakpoints by checking (enabling) or unchecking (disabling) them. This enables you to temporarily focus on nodes in your routing context that are behaving problematically.
The
button skips over disabled breakpoints to jump to the next
active breakpoint in the routing context. In contrast, the
button jumps to the next node of execution in the routing
context, regardless of breakpoints.camel Context.xml view
Displays the running routing context file in graphical mode. For nodes set with breakpoints, it shows the type of breakpoint set and whether the breakpoint is enabled or disabled. When a breakpoint is hit, its corresponding node on the canvas is outlined in red.
To check a node’s configuration, open the Properties view and then select the node on the canvas in
camel Context.xml.Console view
Displays the log output generated by the Camel debugger as it executes the routing context.
Properties view
Displays the properties set for the node selected on the canvas in
CamelContext.xml.