LibraryPrintFeedback

Product Introduction

Version 7.1

December 2012
Trademark Disclaimer
Third Party Acknowledgements

Updated: 08 Jan 2014

Revision History

Table of Contents

1. Introducing Fuse ESB Enterprise
2. The Fuse ESB Enterprise Architecture
Architectural Layers
How Fuse ESB Enterprise Activates a Deployed Bundle
3. Messaging
The Embedded Messaging Service
Standard JMS Features
JMS Message Basics
JMS Development
Extended JMS Features
Flexibility
High Availability
Reliability
Scalability and High Performance
Simplified Administration
4. Routing and Integration
The Embedded Routing and Integration Service
Messages and Message Exchanges
Routing Runtime
Integration Development
5. Web and RESTful Services
The Embedded Web and RESTful Services
Web Service Development Pattern
RESTful Service Development Pattern
6. Centralized Configuration, Deployment, and Management
7. The Major Widgets Use Case
Introducing Major Widgets
Major Widgets Integration Plan: Phase One
Major Widgets Phase One Solution
8. Getting More Information
FuseSource Documentation
Administration
Messaging
Routing and Integration
Web and RESTful Services
Java Business Integration (JBI)
Other Resources
Administration
Messaging
Routing and Integration
Web and RESTful Services
Index

List of Figures

2.1. Fuse ESB Enterprise Architecture
2.2. Steps in activating a deployed route
3.1. Anatomy of a JMS message
3.2. Simple broker program
3.3. Network of brokers example
4.1. Routing and integration service architecture
6.1. A Fabric
7.1. Major Widgets integration plan
7.2. Major Widgets integration solution

An enterprise service bus (ESB) is the back bone of an SOA implementation. Though no canonical definition of an ESB exists, David Chappell states in his book Enterprise Service Bus:

The term extended enterprise describes an organization and its business partners, who are separated by both business and physical boundaries.

An ESB is typically defined by the list of services it provides. Services commonly included are:

  • Transport mediation—not all applications and services that need to be integrated use HTTP or JMS.

  • Dynamic message transformation—not all services use SOAP and are unlikely to require the same message structures.

  • Intelligent routing—not all messages emanating from a source are intended for the same destination. The target destination will likely depend on some criteria inherent in the message.

  • Security—only authorized and authenticated users need have administrative access to the Fuse ESB Enterprise runtime; services and brokers that handle sensitive information may restrict access to unauthorized or unauthenticated clients only; similarly, messages that contain sensitive information may be encrypted as they transit their routes.

An ESB simplifies the complexity of integration by providing a single, standards-based infrastructure into which applications can be plugged. Once plugged into the ESB, an application or service has access to all of the infrastructure services provided by the ESB and can access any other applications that are also plugged into the ESB. For example, you could plug a billing system based on JMS into an ESB and use the ESBs transport mediation features to expose the billing system over the Web using SOAP/HTTP. You could also route internal purchase orders directly into the billing system by plugging the Purchase Order system into the ESB.

Most ESB implementations provide all of the services that are used to define an ESB, so it is hard to differentiate ESB implementations based on features. A better way to differentiate between them is to use the following four measures:

Based on Apache ServiceMix, Fuse ESB Enterprise reduces complexity and eliminates vendor lock-in because it is standards-based and built using best-of-breed, open source technology. It differentiates itself in these ways:

The Fuse ESB Enterprise kernel layer is based on Apache Karaf, an OSGi-based runtime that provides a lightweight container into which you can deploy various components and applications.

The kernel layer interacts with the Services layer to set up, coordinate, and manage logging, and security; and to manage transactions on a per service basis. It also interacts with the Service layer to set up message broker instances with the configuration specified in the supplied activemq.xml file.

The kernel provides these features:

The Fuse ESB Enterprise services layer consists of all of the interfaces and implementation classes for each of the embedded services. It interacts with the application layer to communicate with user-developed applications that want to access and use these services.

Fuse ESB Enterprise's kernel acts much like a mini operating system to create and manage a runtime environment for a deployed application. It does so by setting up an execution environment that meets the requirements specified in the MANIFEST.MF file included in each bundle in an application. It then creates the resources each bundle needs by reading the bundle's Blueprint or Spring XML file. If the bundle is a service provider and contains the necessary publishing information, the kernel registers the service in the OSGi service registry, so any service requester bundle that needs to use the registered service can find and access it.

The kernel interacts with the Services layer to create the resources specified within an OSGi bundle. For example, a service provider bundle that instantiates a message broker might define two connections that use different transports, one HTTP and one JMS. The kernel interacts with the messaging service to set up the message broker with the configuration specified in the bundle's activemq.xml file and creates the required transports.

Figure 2.2 shows the steps involved in activating an example route bundle. A developer would create (1) and deploy (2) a route bundle into Fuse ESB Enterprise's OSGi container. The route bundle would contain business logic (in this case a RouteBuilder class written in Java code), an OSGi MANIFEST.MF file defining the bundle's requirements (dependencies, imports, exports, and so on), and a Blueprint.xml file defining the route's resources.


First, the kernel would read the bundle's MANIFEST.MF file (3) to set up the application's execution environment and resolve bundle dependencies. Then it would read the bundle's Blueprint .xml configuration file (4) to discover and set up the resources needed for the route. The business logic's RouteBuilder class would access the routing and integration service (5) via the OSGi service registry to define the route's CamelContext (the routing runtime).

In both cases, if the bundles were (2) hot deployed, the configured message broker and the route would start up immediately after their resources were in place. Otherwise, the developer or the system administrator would have to issue, at the console command line, osgi:install and osgi:start commands for each bundle.

JMS is a standardized means for transmitting messages between distributed applications. It defines a specific set of required features, a specific message anatomy, and a set of interactions between client applications and the message broker.

Fuse ESB Enterprise' messaging service supports the two messaging domains defined in the JMS 1.1 specification.

For more information, see the Java™ Message Service Maintenance Release.

As shown in Anatomy of a JMS message, a JMS message consists of three components: headers, properties, and body.


Developing applications using the JMS APIs is a straightforward process. The APIs facilitate the creation of objects that mitigate the interface between client applications and the message broker. Once connected to a broker, clients can create, send, and receive messages.

A JMS broker provides connectivity, message storage, and message delivery functions to its clients. It also provides quality of service features, such as reliability, persistence, security, and availability. A simple broker application typically consist of these basic interfaces and classes:



[1] Connection factories and destinations are preconfigured JMS objects, known as administered objects. They contain provider-specific configuration data for clients' use. Clients typically access administered objects through the Java Naming and Directory Interface (JNDI).

This section provides an overview of just some of the extended JMS features that enable developers to build messaging applications that are flexible, highly available, reliable, scalable, highly performant, and easily administered. (See Fuse ESB Enterprise documentation for detailed descriptions and examples of these and other extended features provided by Fuse ESB Enterprise's embedded messaging service.)

[Note]Note

Because these features are not part of the JMS 1.1 specification, to port an application that uses them to another JMS provider, you'd most likely need to rewrite the sections of code that use them.

A master/slave topology defines an initial master broker and one or more initial slave brokers. When the master broker fails, one of the slave brokers starts up and takes over, becoming the new master broker. Clients using the failover protocol can reconnect to the new master broker and resume processing as normal.

Slave brokers have access to all messages sent to the master broker. Whether all messages are replicated from the master broker to the slaves depends on whether or not the topology includes a shared message store.

For details, see the Fault Tolerant Messaging.

When a message cannot be delivered to its destination, the broker sends it to the dead letter queue, ActiveMQ.DLQ. When a message is sent to the dead letter queue, an advisory message is sent to the topic ActiveMQ.Advisory.MessageDLQd.*. (See Advisory messages.

Messages held in the dead letter queue can be consumed or reviewed by an administrator at a later time. Reviewing the contents of the dead letter queue helps to debug delivery issues and to prevent messages loss.

For details, see ActiveMQ in Action (Snyder, Bosanac, and Davies).

As shown in Figure 3.3, the brokers in a network of brokers are connected together by network connectors, which define the broker-to-broker links that form the basis of the network. Through network connectors, a network of brokers keeps track of all active consumers[3], receiving notifications whenever a consumer connects to or disconnects from the network. Using the information provided through client registration, brokers can determine where and how to route messages to any consumer in a network of brokers.


The brokers use a store-and-forward delivery method to move messages between them. A broker first stores messages locally before passing them on to another broker in its network. This scheme supports the distribution of queues and topics across a network of brokers.

For details, see Using Networks of Brokers.

[Tip]Tip

You can incorporate multiple master/slave topologies in networks of brokers to ensure a fault tolerant messaging system.

For details, see Master/Slave and Broker Networks in Fault Tolerant Messaging.

Fuse ESB Enterprise's messaging service provides many ways to manage and administer a messaging system.



[2] The default wire protocol used to serialize data for transmission over the network connection is OpenWire (see Client-side APIs).

[3] Active consumers are those that are connected to a networked broker, have registered interest in a particular topic or queue, and are ready to receive messages from it

Fuse ESB Enterprise's routing and integration service makes it easy to develop integration solutions. Some of its features are:

Routes specify paths over which messages move. Processors execute actions on messages (such as routing, transformation, mediation, enrichment, validation, interception, and so on) as they move between the route's consumer and producer endpoints.

You create processors using the supported EIPs or by building your own. For more details, see the Programming EIP Components.

You create routes in routing rules by wiring a string of processors together between a consumer and one or more producer endpoints. The output from one processor in the string is the input into the next one.

Routing rules are declarative statements (written in Java or XML DSL) that define the paths which messages take from their origination (source) to their target destination (sink). Routing rules start with a consumer endpoint (from) and typically end with one or more producer endpoints (to). Between the consumer and producer endpoints, messages can enter various processors, which may transform them or redirect them to other processors or to specific producer endpoints. For example, the Java DSL choice() method creates a content-based router;

which, based on the specified predicate, directs messages to one or the other producer endpoint.

Figure 7.2 shows an example that employs five routes and two processors. The consumer endpoint, camel-cxf (3), receives part order requests and passes them to a content-based router processor (4), which pushes each onto one of the four store's queue (5), according to the part order's zip code. If a part order's zip code fails to match any of the zip codes on its list, the content-based router processor pushes the part order onto the deadOrders queue. In the back end routing runtime, the dynamic router processor (6) directs orders to different destinations based on whether the ordered parts are available.

Fuse ESB Enterprise's embedded Web and RESTful services framework supports a variety of standards and protocols for creating web services:

Fuse ESB Enterprise allows you deploy a group of containers into a fabric. All of the brokers in a fabric are managed by a distributed Fabric Ensemble that stores runtime and configuration information for all of the containers in the fabric. Using this information the ensemble enables you to manage large deployments by:

  • automating the configuration of message brokers into failover groups, networks of brokers, and master/slave groups

    The ensemble knows the connection details for all of the brokers in the fabric and uses that information to configure brokers into different configurations. Because the information is updated in real time, the broker configurations are always correct.

  • automating client connection, failover, and load balancing configuration

    When services, including message brokers, are configured into a fabric, clients can use special discovery protocols that queries the ensemble for an appropriate service instance or message broker. The ensemble uses a round robin algorithm for balancing load among common service instances in the fabric. The fabric discovery connection will also automatically failover to other service instances without needing to know any details about what instances are deployed.

  • centralizing configuration information

    All of the configuration for each container in the fabric, including details about which bundles are deployed, are stored in the ensemble. Any of the configurations can be edited from a remote location and directly applied to any container in the fabric.

  • simplifying the enforcement of common configuration policies

    The ensemble organizes configuration information into profiles that can inherit from each other. This makes it easy to enforce common policies about how brokers need to be configured using base profiles.

  • centralizing management and monitoring functionality

    Using Fuse Management Console, Fuse IDE, or the Fuse ESB Enterprise command console you can update configuration profiles, deploy new containers, shutdown containers, and get runtime metrics for any of the containers in the fabric

Major Widgets integration solution shows how phase one of Major Widgets integration plan might be implemented.


[Note]Note

The encircled numbers in Figure 7.2 serve as reference points for concepts presented in this guide.

For example, (1) in the text references encircled numberwhere ever it appears in these figures.

At Major Widgets main store (A), the order entry front end (routing and messaging agents running inside Fuse ESB Enterprise) is running on that store's main computer system. At each of the four stores (A-D), an instance of the order entry back end (routing agent and back end processing running in Fuse ESB Enterprise) is running on the local computer system.

When the front end web service (3) receives an online order, the routing agent passes it to a content-based router (4) to determine which store to route the part order for further processing. Normally, the order then enters the target store's queue (5), where it waits until the target store retrieves it (6). (With fault tolerance built into the system, if the master broker (5) fails, the system can continue to function with no loss of orders. For details, see Built-in Broker Fault Tolerance.)

In the case of auto repair shops (1), the content-based router routes order requests to the store nearest the customer, based on the submitted zip code. In the case of walk-in customers (2), the auto supply store submits its own zip code to the front end, so the order is always routed to the local store.

When the back end receives the submitted part order, the application employs a dynamic router (6) to look up the parts in the store's database to see if they are in stock. Results depend on whether the customer is an auto repair shop or a walk-in:

  • Auto repair shop customers

    If the parts are available, the order is submitted to the store's back end processing software (8), which informs and bills the customer (1), schedules delivery, updates inventory, and reorders parts accordingly.

    If the parts are unavailable, the order is submitted to a processor that generates an error message, which is emailed (9) to the customer (1).

  • Walk-in customers

    If the parts are available, the order is submitted to the store's back end processing software (8), which informs the store clerk (2), updates inventory, and orders parts accordingly. The store clerk retrieves the parts from stock and sells them to the customer over-the-counter.

    If the parts are unavailable, the order is submitted to a processor that generates an error message, which is emailed (9) to the local store's email account (2). The store clerk informs the customer, who can then decide whether he wants the store clerk to search the other stores for his parts.

Figure 7.2 shows how the Major Widgets integration plan implements a fault-tolerant mechanism to protect against loss of orders due to broker failure.

In this scenario, a slave broker (5a), which provides fault tolerance for the messaging system, is running within Fuse ESB Enterprise (FESB) on a separate, backup computer system at the main store. Both master broker and slave broker connect (5.2/5b) to a shared file system located on a storage area network (SAN). In addition, the messaging system has been configured for persistent messaging, storing messages to disk until consumers acknowledge their receipt, to protect against message loss. And all clients have been configured to use the failover transport to enable them to automatically reconnect to the slave broker when the master broker fails.

With the message store set up, the first broker ((5) in the Major Widgets scenario) to grab an exclusive lock on the shared file system becomes the master broker. The slave broker loops, waiting to grab the exclusive lock when it becomes available. When the master broker (5) fails, it immediately shuts down its transport connections (5.1) to all clients and gives up the exclusive lock on the shared file system (5.2). Concurrently, the slave broker (5a) activates its transport connections to all clients (5c) and grabs the file system lock (5b). Doing so, the slave broker becomes master broker. When the former master broker restarts, it becomes the slave broker and waits to grab the exclusive lock whenever it becomes available.

When the master broker fails, all clients configured to fail over reconnect automatically to the next broker in the supplied list—in this case the initial slave broker (5a). Because the Major Widgets scenario employs a cluster of only two brokers, subsequent failures cause the brokers to switch master/slave roles back and forth between them.

For details on persistent messaging, see Configuring Message Broker Persistence. For details on the failover protocol, see Failover Protocol in Fault Tolerant Messaging.

All of these documents are part of the Fuse ESB Enterprise library, downloadable from the Fuse ESB Enterprise documentation Web site. A few require that you register with FuseSource before you can view them.

The books listed here provide information and instructions for installing and setting up Fuse ESB Enterprise in preparation for developing, deploying, and administering enterprise integration solutions.

  • Fuse ESB Enterprise Release Notes

    You'll find the release notes for the latest version of Fuse ESB Enterprise here. For each version, the release notes list and describe bug fixes and new improvements included in the newly released software.

  • Installation Guide

    Provides detailed instructions for installing the Fuse ESB Enterprise software on Windows, Linux, Unix, and OS X platforms, using the binary distributions or building from source code. It also lays out the prerequisites needed to ensure a successful installation.

  • Migration Guide

    Describes all of the latest changes made to the Fuse ESB Enterprise software and, where necessary, provides instructions for integrating the changes into existing systems.

  • Configuring and Running Fuse ESB Enterprise

    Provides information and instructions for starting/stopping Fuse ESB Enterprise, using remote and child instances of the runtime, configuring Fuse ESB Enterprise, configuring logging for the entire runtime or per component application, configuring where persistent data (messages, log files, OSGi bundles, transaction logs) is stored, and configuring failover deployments.

  • Glossary

    Defines terms used through out FuseSource product documentation.

The books listed here provide information and instructions for deploying OSGi-based applications and managing their dependencies, for securing Fuse ESB Enterprise and some of its embedded components, and for using each of the console commands.

  • Deploying into the Container

    Describes how to bundle and deploy OSGi-based applications (features, Jars, Wars, routes, web services, brokers, OSGi services, and more) into Fuse ESB Enterprise's OSGi container. It also describes how to perform interbundle communication using the NMR, the Pax-Exam testing framework, URL handlers, and OSGi best practices.

  • Managing OSGi Dependencies

    Describes basic OSGi class loading concepts, the rules for importing and exporting packages in relation to the type of OSGI bundles used in an application, and OSGi version policies so you can avoid incurring incompatible dependencies in your application.

  • Security Guide

    Describes how to secure the Fuse ESB Enterprise container, the web console, message brokers, routing and integration components, web and RESTful services, and it provides a tutorial on LDAP authentication.

    You must register at fusesource.com/register before you can view this document located on the Documentation tab at Fuse ESB Enterprise.

  • Console Reference

    Lists and describes all of Fuse ESB Enterprise's console commands. These commands allow you to manage the Fuse ESB Enterprise runtime and its embedded components.

  • ESB API Reference

    Includes API references for Fuse ESB Enterprise's kernel (Apache Karaf and Apache Felix), Apache ActiveMQ (messaging), Apache Camel (routing and integration), Apache CXF (Web and RESTful services), the JBI (Java Business Integration) components, and the NMR (Normalized Message Bus).

The books listed here provide information about JMS messaging and instructions for developing basic messaging applications—those that do not implement transactions.

  • Broker Client Connectivity Guide

    Describes each of the supported transport options and connectivity protocols in detail and includes code examples.

  • Configuring Message Broker Persistence

    Describes the basic concepts of message persistence and provides detailed information on the supported message stores: KahaDB and JDBC database with/without journaling. It also describes how to use message cursors to improve the scalability of the message store.

  • Using Networks of Brokers

    Describes basic network of brokers concepts and topologies, network connectors, failover and discovery protocols for dynamically discovering and reconnecting to brokers in a network, as well as balancing consumer and producer loads

    You must register at fusesource.com/register before you can view this document.

  • Fault Tolerant Messaging

    Describes how to implement fault tolerance using master/slave broker patterns.

  • Fuse ESB Enterprise 5.5.0 XML Schema Reference

    Links to Apache ActiveMQ vx.x XML Schema Reference, where, for each namespace, all available components are listed. This is the configuration reference for Apache ActiveMQ.

The books listed here provide information and instructions for implementing transactions and for securing message brokers, and accessing all available message broker classes.

The books listed here provide information and instructions for developing basic integration and routing applications—those that do not implement transactions or require custom-built processors.

  • Implementing Enterprise Integration Patterns

    Describes how to build routes from the basic building blocks and principals to the supported Enterprise Integration Patterns (EIPs).

  • Programming EIP Components

    Chapters 1 through 5 describe routing and integration basics and provide instructions for working with processors, type converters, consumer and producer templates, and components.

  • Deploying into the Container

    Describes how to bundle and deploy routes into the OSGi container and how to invoke an OSGi service from within a route.

  • API Reference

    Links to FuseSource Distribution of Camel API, where, for each package, all available classes are listed.

  • Apache Camel XML Schema Reference

    Links to Apache Camel 7.1 XML Schema Reference, where, for each namespace, all available components are listed. This is the reference for the embedded routing and integration service's XML domain-specific language.

The books listed here provide information and instructions for implementing transactions and for building custom processors.

  • Programming EIP Components

    Chapters 6 through 11 describe how to work with component, endpoint, consumer, producer, exchange, and message interfaces, so you can create and implement your own custom components and processors.

  • EIP Transaction Guide

    Describes the basic concepts of transactions, how to select and implement a transaction manager, how to access data using Spring, the various ways to demarcate transactions, and JMS transaction semantics.

    You must register at fusesource.com/register before you can view this document from the Apache Camel web page.

The following reading paths provide quick summaries on how to accomplish many of the development tasks when working with the Web and RESTful services framework:

  • Introducing WSDL Contracts in Writing WSDL Contracts provides a quick overview of the contents of a WSDL document.

  • Developing a Consumer From a WSDL Contract in Developing Applications Using JAX-WS describes how to develop a service consumer using a provided WSDL document. It discusses how to use the command-line tools to generate the stubs and what additional code is required.

  • Developing a Consumer Without a WSDL Contract in Developing Applications Using JAX-WS describes how to develop a service consumer if you are provided a Java interface instead of a WSDL document.

  • Developing Asynchronous Applications in Developing Applications Using JAX-WS describes how to develop consumers that make asynchronous invocations on remote services.

  • Using XML in a Consumer in Developing Applications Using JAX-WS describes how to use the Dispatch interface to develop consumers that work with raw XML messages.

  • Creating the SEI in Developing Applications Using JAX-WS describes how to develop a SEI for your service.

  • Annotating the Code in Developing Applications Using JAX-WS describes the annotations used by the JAX-WS framework.

  • Using XML in a Service Provider in Developing Applications Using JAX-WS describes how to use the Provider interface to develop services that work with raw XML messages.

  • Publishing a Service in Developing Applications Using JAX-WS describes the code needed to publish a service as a standalone application.

  • Introduction to RESTful Web Services in Developing RESTful Web Services provides an overview of RESTful design principles.

  • Root resource classes in Developing RESTful Web Services describes how to create a root resource class for the resource that represents the top of the service's resource tree.

  • Working with sub-resources in Developing RESTful Web Services describes how to map the service's other resources into sub-resources.

  • Working with resource methods in Developing RESTful Web Services describes how to create methods to implement each of the HTTP verbs used by each of the resources.

  • Publishing a Service in Developing RESTful Web Services describes how publish your service.

The books listed here provide information and instructions for creating, building, and deploying JBI applications.

  • Using Java Business Integration

    Provides an overview of JBI, introducing the JBI framework and management structure; describes how to deploy JBI artifacts into the Fuse ESB Enterprise runtime; and how to use the JBI console commands.

  • Using the JMS Binding Component

    Provides an overview of the JBI JMS binding component; describes how to configure the connection factory, how to create and configure various types of endpoints, and how to use the Maven tooling.

  • Using the Apache CXF Binding Component

    Provides an overview of the JBI CXF binding component; describes how to define endpoints in WSDL, how to configure and package endpoints, and how to configure the CXF runtime; describes the properties of consumer and provider endpoints; and describes how to use the Maven tooling.

  • Using the File Binding Component

    Provides an overview of the JBI file binding component; describes configuring and using poller and sender endpoints and file marshallers; describes the properties of poller and sender endpoints; and describes how to use the Maven tooling.

This section provides links to webinars, video demos, and 3rd party books and articles. Check the FuseSource web site often for new webinars and video demos.

The resources listed here are freely available from the FuseSource website at FuseSource Resources.

  • Overview of OSGi Enterprise

  • Introduction and Demo of Distributed OSGi

  • Transactions, Clustering, OSGi and ServiceMix, the Open Source ESB

  • Large-Scale Deployments & ServiceMix 4

The resources listed here are freely available from the FuseSource website at FuseSource Resources.

  • Getting Started with Apache ActiveMQ

  • Get started with ActiveMQ High-Availability

  • Performance Tuning for ActiveMQ

  • Reliable Messaging to the Browser

  • Deploying ActiveMQ in the Enterprise

The resources listed here are freely available from the FuseSource website at FuseSource Video demos

  • Overview of JMS Messaging Concepts

    If you are already familiar with the basics of JMS messaging, you can dive directly into the Guided Tour demo.

  • Setting up: The Guided Tour

    The Guided Tour sequentially walks you through setting up and running a number of example applications. Each example in the sequence builds upon the concepts introduced in previous ones.

    • Publish & Subscribe Examples

      • Chat application

      • Durable Chat application

      • Hierarchical Chat application

      • Message Monitor

      • Selector Chat

      • Transacted Chat

    • Point-to-Point Examples

      • Talk

      • Queue Monitor

The resources listed here are freely available from the FuseSource website at FuseSource Resources.

  • Getting Started with Apache Camel

  • Database Integration with Apache Camel

  • Apache Camel: From EIPs to Production

  • Enterprise Integration: Patterns and Deployments

  • Apache Camel Deployment Options

  • The Top Twelve Integration Patterns with Apache Camel

The resources listed here are freely available from the FuseSource website at FuseSource Video demos

  • Introduction to Apache Camel

  • Overview of Apache Camel

  • Throttler Enterprise Integration Pattern

  • Splitter Enterprise Integration Pattern

  • Composed Enterprise Integration Pattern

The books and reference materials listed here provide detailed information and instructions for designing, building, and deploying enterprise integration solutions and for using the tools that make it easier to do so. The books and reference materials in this list were authored by leading experts in this domain.

A

Active consumers, defined, Network of brokers
Advisory messages, described, Advisory messages
Apache ActiveMQ information resources
Fuse documentation, Developer—basics
Fuse video demos, Video demos, Video demos
Fuse webinars, Webinars, Webinars
third-party books & articles, Third party books and articles
Apache Karaf, The Kernel Layer

B

B2B (see Business-to-business)
Blob (binary large objects) messages
data storage, Blob (binary large objects) messages
described, Blob (binary large objects) messages
Broker
durable subscribers, Durable subscribers
integration, described, Message routing
Broker connection
described, Basic application components
program example, Simple broker program
Broker program example
connection factory, get, Simple broker program
connection, create, Simple broker program
connection, start, Simple broker program
consumer, create, Simple broker program
consumer, receive message, Simple broker program
destination, create, Simple broker program
diagram of, Simple broker program
message, create, Simple broker program
print out list of messages received, Simple broker program
producer, create, Simple broker program
producer, send message, Simple broker program
program sequence, Simple broker program
session, create, Simple broker program
Business-to-business, Integration problems

C

CamelContext (see Routing and integration service)
Code-first development, web services, Overview
Composite messaging destinations, described, Composite destinations
configuration
profiles, Profiles
versions, Profiles
Connection factory
described, Basic application components
program example, Simple broker program
Console, The Kernel Layer
consumer clusters, Consumer clusters
load balancing across queues, Consumer clusters
Contract-first development, web services, Overview

D

Data bindings
JAXB, Data binding options, JAXB data bindings
JSON, Data binding options, JSON data bindings
web and RESTful services, Data binding options
XMLBeans, Data binding options
Dead letter queue, described, Dead letter queue
Dependency injection frameworks
Blueprint, The Kernel Layer
Spring, The Kernel Layer
Deployment options, The Kernel Layer, Deployment options
Durable subscribers, described, Durable subscribers

E

EAI (see Enterprise application integration)
Endpoints
consumer, Endpoints
described, Endpoints
producer, Endpoints
ensemble, Fabric Ensemble
Enterprise application integration, Integration problems
Enterprise integration patterns
described, Features
processors, and, Features
Enterprise service bus, described, The ESB approach
ESB (see Enterprise service bus)
Exclusive consumers, described, Exclusive consumers
Extended enterprise, described, The ESB approach
Extended messaging features
flexibility, Overview
high availability, High Availability
reliability, Overview
scalability and high performance, Scalability and High Performance
simplified administration, Simplified Administration

F

FAB
described, The Fuse ESB Enterprise approach, FABs in a nutshell
OSGi bundles, and, FABs in a nutshell
pom.xml file, and, FABs in a nutshell
fabric
agent, Fabric Agents
ensemble, Fabric Ensemble
profiles, Profiles
versions, Profiles
Fabric Agent, Fabric Agents
Fabric Ensemble, Fabric Ensemble
Failover protocol
described, Fault tolerance and the failover protocol
master/slave broker topologies, Master/Slave topologies
Fault tolerance
described, Fault tolerance and the failover protocol
master/slave broker topologies, Master/Slave topologies
messaging system example, diagram of, Major Widgets Phase One Solution
network of brokers, and, Network of brokers
use case example, Major Widgets solution components
Flexibility messaging features
broker integration, Message routing
client-side APIs, Client-side APIs
composite destinations, Composite destinations
connectivity options, Overview, Connectivity options
deployment options, Deployment options
virtual destinations, Virtual destinations
Flexible messaging system, described, Overview
Fuse Application Bunble (see FAB)
Fuse ESB Enterprise architecture
application layer, Overview, The Application Layer
diagram of, Architectural Layers
kernel layer, Overview, The Kernel Layer
services layer, Overview, The Services Layer
Fuse ESB Enterprise configuration, The Kernel Layer
Fuse ESB Enterprise console, The Kernel Layer
Fuse ESB Enterprise embeded services
JBI, The Services Layer
messaging, The Services Layer
Normalized Message Router, The Services Layer
RESTful services framework, The Services Layer
routing and integration, The Services Layer
transaction manager, The Services Layer
web services framework, The Services Layer
Fuse ESB Enterprise kernel layer
described, The Kernel Layer
features, The Kernel Layer
configuration, The Kernel Layer
console, The Kernel Layer
dependency injection frameworks, The Kernel Layer
deployment, The Kernel Layer
FAB, The Kernel Layer
logging, The Kernel Layer
OSGi container, The Kernel Layer
provisioning, The Kernel Layer
security, The Kernel Layer
Fuse ESB Enterprise OSGi container, The Kernel Layer
Fuse ESB Enterprise provisioning, The Kernel Layer
Fuse ESB Enterprise security, The Kernel Layer
Fuse ESB Enterprise services layer
described, The Services Layer
embedded services, The Services Layer

H

High availability messaging features
described, High Availability
failover protocol, Fault tolerance and the failover protocol
fault tolerance, Fault tolerance and the failover protocol
master/slave broker topologies, Master/Slave topologies
High-performance messaging features
blob (binary large objects) messages, Blob (binary large objects) messages
large message bottlenecks, avoiding, Overview
network of brokers, Network of brokers
scheduled message delivery, Scheduled message delivery
stream messages, Stream messages
Horizontal scaling, described, Overview
Hot deployment, The Kernel Layer, Bundle bootstrapping process
HTTP/S protocol, Connectivity options

I

Integration solution example
diagram of, Major Widgets Phase One Solution
fault tolerance, Major Widgets solution components
Major Widgets use case, Introducing Major Widgets
IP multicast protocol, Connectivity options

J

Java message types, Message body
JAX-RS, RESTful services front end, Font end options
JAX-WS, web services front end, Font end options
JBI, The Services Layer
JMS 1.1 specification, Standard JMS Features
JMS application components
described, Basic application components
list of, Basic application components
JMS features, standard, Standard JMS Features
JMS message headers, Message headers and properties
JMS message properties, Message headers and properties
JMS transactions, JMS transactions
message selectors, Message headers and properties
messaging domains, Queue- and topic-based messaging
nonpersistent messages, Persistent and nonpersistent messages
persistent messages, Persistent and nonpersistent messages
Point-to-Point (PTP), Queue- and topic-based messaging
Publish/subscribe (Pub/Sub), Queue- and topic-based messaging
Request/reply messaging, Request/reply messaging
XA transactions, XA transactions
JMS message headers
described, Message headers and properties
JMSXGroupID, Message groups
producer's send() method, and, Message headers and properties
JMS message properties
described, Message headers and properties
JMS-defined, Message headers and properties
user-defined, Message headers and properties
vendor-specific, Message headers and properties
JMS messages
anatomy of, Message anatomy
body, Message body
consuming from queues in correct order, Exclusive consumers
described, Overview, Basic application components
headers, Message headers and properties
Java message types, Message body
message create, program example, Simple broker program
message receive, program example, Simple broker program
message selectors, Message headers and properties
message send, program example, Simple broker program
properties, Message headers and properties
JMS transactions, JMS transactions
JMX console, administration tool, JMX

K

kernel layer, The Kernel Layer

M

Major Widgets use case
example integration solution, Introducing Major Widgets
fault tolerance example, Major Widgets solution components
integration solution, diagram of, Major Widgets Phase One Solution
Master/slave broker topologies
described, Master/Slave topologies
network of brokers, and, Network of brokers
shared database/file system networks, Master/Slave topologies
shared-nothing networks, Master/Slave topologies
MEP (see Message exchanges)
Message bindings
SOAP, Message binding options
web and RESTful services, Message binding options
XML, Message binding options
Message exchanges, described, Message exchange basics
Message groups
described, Message groups
JMSXGroupID header, Message groups
Message redelivery, described, Message redelivery
Message selectors, described, Message headers and properties
MessageConsumer interface, described, Basic application components
MessageProducer interface, described, Basic application components
Messaging client-side APIs
list of, Client-side APIs
programming languages, supported, Client-side APIs
wire protocols, Client-side APIs
Messaging clients
active consumers, Network of brokers
broadcasting messages through a topic to a pool of queue subscribers, Virtual destinations
consumers, Queue- and topic-based messaging, Basic application components
multiple destinations, concurrently sending the same message to, Composite destinations
producers, Queue- and topic-based messaging, Basic application components
publishers, Queue- and topic-based messaging
receivers, Queue- and topic-based messaging
senders, Queue- and topic-based messaging
subscribers, Queue- and topic-based messaging
Messaging connectivity options, list of, Connectivity options
Messaging consumer
described, Queue- and topic-based messaging, Basic application components
durable subscribers, Durable subscribers
exclusive consumers, Exclusive consumers
MessageConsumer interface, Basic application components
messages, receiving and processing, Basic application components
program example, Simple broker program
retroactive consumers, Retroactive consumers
Messaging destinations
composite destinations, Composite destinations
described, Basic application components
program example, Simple broker program
virtual destinations, Virtual destinations
Messaging domains
Point-to-Point (PTP), Queue- and topic-based messaging
Publish/subscribe (Pub/Sub), Queue- and topic-based messaging
Messaging interceptors
authentication, Interceptor plug-ins
central timestamp, Interceptor plug-ins
described, Interceptor plug-ins
enhanced logging, Interceptor plug-ins
list of, Interceptor plug-ins
statistics, Interceptor plug-ins
visualization, Interceptor plug-ins
Messaging producer
default destination, Basic application components
described, Queue- and topic-based messaging, Basic application components
JMS headers and properties, setting, Basic application components
MessageProducer interface, Basic application components
messages, sending, Basic application components
program example, Simple broker program
Messaging session
described, Basic application components
program example, Simple broker program
Messaging, described, The Services Layer

N

Network of brokers
described, Network of brokers
example, diagram of, Network of brokers
fault tolerance, Network of brokers
master/slave networks, and, Network of brokers
network connectors, Network of brokers
network topologies, Network of brokers
store and forward delivery mode, Network of brokers
vs standalone broker clusters, Fault tolerance and the failover protocol
NIO protocol, Connectivity options
NMR (see Normalized Message Router)
Nonpersistent messaging, described, Persistent and nonpersistent messages
Normalized Message Router, The Services Layer

O

OpenWire protocol, Connectivity options
OSGi
advantages of, OSGi in a nutshell
bundles, OSGi in a nutshell
described, OSGi in a nutshell
framework, OSGi in a nutshell
service registry, Bundle bootstrapping process
OSGi bundles
bootstrapping process, Bundle bootstrapping process
described, OSGi in a nutshell
FABs, and, FABs in a nutshell
MANIFEST.MF file, and, Bundle bootstrapping process
route activation, example of, Bundle bootstrapping process

P

Persistent messaging
broker configuration, Persistent and nonpersistent messages
described, Persistent and nonpersistent messages
Point-to-Point (PTP) messaging
clients, Queue- and topic-based messaging
described, Queue- and topic-based messaging
destinations, Queue- and topic-based messaging
Publish/subscribe (Pub/Sub) messaging
clients, Queue- and topic-based messaging
described, Queue- and topic-based messaging
destinations, Queue- and topic-based messaging

Q

Queue-based messaging, Queue- and topic-based messaging

R

Reliability messaging features
dead letter queue, Dead letter queue
durable subscribers, Durable subscribers
exclusive consumers, Exclusive consumers
message groups, Message groups
message redelivery, Message redelivery
retroactive consumers, Retroactive consumers
Request/reply messaging, described, Request/reply messaging
RESTful services framework, The Services Layer
described, Overview
JAX-RS development benefits, JAX-RS development
JSON data bindings, JSON data bindings
Retroactive message consumers
described, Retroactive consumers
persistent messaging alternative for improved reliability, Retroactive consumers
Routing and integration service, The Services Layer
components, Components
described, Overview
development process, Integration Development
endpoints, described, Endpoints
enterprise integration patterns, Overview
jbi: component, The Services Layer
message anatomy, Message basics
message exchanges, anatomy of, Message exchange basics
nmr: component, The Services Layer
processors, Features, Routes and processors
routes, Routes and processors
routing rules, Routes and processors
routing runtime, Overview
type converters, Features

S

Scalability and high performance, described, Scalability and High Performance
Scalability messaging features
horizontal scaling, Overview
network of brokers, Network of brokers
vertical scaling, Overview
Scheduled message delivery
described, Scheduled message delivery
enabling, Scheduled message delivery
ScheduledMessage properties, Scheduled message delivery
Service oriented architecture, Integration problems
Shared database/file system networks
benefits of, Master/Slave topologies
described, Master/Slave topologies
integration solution, diagram of, Major Widgets Phase One Solution
Shared-nothing master/slave networks
described, Master/Slave topologies
masterConnectorURI connector, Master/Slave topologies
Simplified messaging administration features
advisory messages, Advisory messages
interceptor plug-ins, Interceptor plug-ins
JMX, JMX
web console, Web Console
SOA (see Service oriented architecture)
SSL protocol, Connectivity options
STOMP protocol, Connectivity options
Store and forward delivery mode, described, Network of brokers
Stream messages
described, Stream messages
vs blob messages, Blob (binary large objects) messages

T

TCP protocol, Connectivity options
Topic-based messaging, Queue- and topic-based messaging
Transactions
JMS, JMS transactions
transaction manager, The Services Layer
XA, XA transactions

U

UDP protocol, Connectivity options

V

Vertical scaling, described, Overview
Virtual messaging destinations
described, Virtual destinations
topic functionality, leveraged over queues, Virtual destinations
VM protocol, Connectivity options

W

Web and RESTful services framework
binary & legacy protocols, The Embedded Web and RESTful Services
data bindings, Data binding options
front end options, Font end options
front end programming standards, The Embedded Web and RESTful Services
message bindings, Message binding options
transport options, Transport options
Web console, administration tool, Web Console
Web services framework, The Services Layer
code-first development, Overview
contract-first development, Overview
data exchange format, Data exchange format
JAXB data bindings, JAXB data bindings
supported standards, The Embedded Web and RESTful Services
Wire protocol
described, Connectivity options
OpenWire, Connectivity options
STOMP, Connectivity options

X

XA transactions, XA transactions
XMPP protocol, Connectivity options