Cape Clear, Iona, and Sonic suites lead the way toward services-based integration
On the upside, FioranoESB offers solid messaging underpinnings and a good set of prebuilt services. You can easily extend the system using a variety of programming languages, including Java, C/C++, COM, and C# for .Net client development. Fiorano’s messaging architecture may create a lot of overhead, but the end points are chock-full of resources.
FusionWare Integration Server 3.0
FusionWare’s flagship product features a Java server framework for mediating communications, backed by a Windows-native IDE for designing process workflows and a GUI for server management. The Integration Server’s licensing model offers an interesting way to control deployment costs, and the IDE provides some nice wizards for easing development. Ultimately, however, this suite is suitable only for small, centralized integration projects.
FusionWare’s licensing structure is unique among vendors in our roundup. Licensed by the number of concurrent processing threads, the server ticks down the number of available threads with each inbound request. When a server’s thread count is exhausted, new requests sit in the message queue until a running process completes or is suspended, and a thread becomes available again.
The licensing scheme offers a sign of the solution’s limited scalability. Although you can purchase and install additional worker threads to meet growing demand, I was disappointed to discover that there was no way to pool licenses across multiserver installations.
FusionWare’s tools are also a mixed bag. The Designer IDE is adequate for creating workflows, but can be somewhat cumbersome at times, as it lacks many of the visual queues and graphical tools for streamlining tasks that are commonly available from competing vendors. On the upside, the Business Process Wizard does a good job of jump-starting a project framework, including storing assets and text-based workflow configurations.
FusionWare’s XSLT wizard takes a different approach than most XSLT tools, which typically offer a visual map of inputs to outputs. Instead, XML transforms are done through an interesting two-step process, which involves pre-parsing the input structure to isolate pertinent data items before mapping them out. I personally found the process somewhat convoluted, but it would certainly minimize complexity in handling large document structures.
I’d like to see FusionWare adopt a workflow standard, such as BPEL, and incorporate features for transaction compensation and exception handling. Although a new tool has been added to test deployments, tighter integration of versioning, management, and project deployment is needed. Debugging also could be more efficient. The IDE allowed me to set basic breakpoints, but having to jump to a text-based, command line interface to execute debug processing was a pain. This would not pass muster in high volume shops.
FusionWare is also light on administrative features. It provides only very basic insight into queue conditions and service status. Better metrics and auditing will be a definite requirement for enterprise installs. Until FusionWare drops them in, customers should plan on building their own.
This product also lacks a strong enterprise footing when it comes to transport support -- currently limited to HTTP and e-mail -- and security, where FusionWare’s support for the basics, such as HTTP/S and simple password-based authentication, may not be sufficient to meet advanced encryption and authentication requirements. These and other shortcomings, including the absence of extensions to external management systems, the failure to support advanced b-to-b protocols (RosettaNet, ebXML, etc.), and the lack of ERP or SCM adapters, for example, relegate FusionWare to small-scale implementations.
Iona Artix 3.0 Advanced
One of the biggest names in legacy integration is Ireland’s Iona Technologies. Not surprisingly, Iona brings to its ESB a strong feature set for mainframe transaction bridging, MOM-based systems, and CORBA transports, as well as its Adaptive Runtime Technology plug-in architecture and a new J2EE service connector.
What impressed me most about Artix is its ready adaptability for old-school protocols such as IIOP (Internet Inter-ORB Protocol) and CICS, and support for security services such as single sign-on. Iona is truly a top-tier player in these respects.
The new Eclipse-based development environment could benefit from more wizard-driven shortcuts like the one for pulling WSDL out of old Cobol Copybooks. Although a bit buggy, it does a wonderful job.
In addition to supporting port- and protocol-based routing, Artix can be configured to take routing directives from message headers but not yet message content. Artix supports dynamic services binding through a central directory and repository called the Locator service.
Data format translations within the bus are performed directly, without first having to convert data into an intermediate language such as XML, speeding throughput but also creating hard-coded, application-specific interfaces. Artix supports XSLT scripts, as well.
Security underpinnings are good. Artix supports LDAP and Microsoft Active Directory, ACLs, single sign-on, and role-based authorizations, as well as Kerberos authentication and WS-Security.
Note, however, that this platform fails to implement process orchestration and activity monitoring. For simple, stateless transactions, I linked together services using the included Chain Builder, a plug-in for constructing services and transformations into preformed process definitions. For processes of any complexity, though, you’ll want to layer on third-party BPM.
Clearly Iona has chosen to focus on fundamentals, but a few other additions would help to round out the Artix package. These include real-time dashboards, tighter services version control, the ability to monitor dependencies among services to better facilitate change management, and better plug-ins for enterprise applications from vendors such as SAP and Oracle. Customers in financial services, health care, and other verticals would also benefit from best-practices process templates.
Provisions for transactional reliability and integrity, however, are top notch. Artix supports session management, two-phase commit (XA/2PC) for long-running processes, and the WS-AtomicTransaction and WS-Context specifications. It is solidly fortified with redundancy, load balancing, and hot-swap of services, and it offers a run time that can be deployed on almost any platform — from IBM AIX and z/OS to Linux and Windows. And the QoS features are among the best I’ve seen in an ESB implementation.
Naturally, such creature comforts (or enterprise necessities) come at a price. The per-CPU run-time licensing associated with each distributed container means that large deployments won’t come cheap, especially when you consider that a good number of enterprise “extras,” such as operational logging and management system adapters come at additional cost.
On the other hand, you get what you pay for. Committed to modernizing old-world systems with the new, Iona’s Artix 3.0 Advanced does what it does very well. This package is a heavyweight contender for addressing large-scale system integration projects in a services-oriented way.
PolarLake Integration Suite 4.0
Built on PolarLake’s Java-centric service bus, JIntegrator, the PolarLake Integration Suite 4.0 sports a nice collection of tools and connectors plus some basic features for ensuring quality of service that make it worthy of consideration for small to midsize deployments. Limited BPEL support and shortcomings in tools and activity monitoring make it a difficult sell for large installations.
PolarLake makes use of a “circuits” metaphor to represent collections of XML-based configuration files, processes, and transports controlled by its servers. Circuits may contain details for data transformation, database integration, attaching to a JMS pipe, or adding monitoring and reporting functionality within a process, to name a few. A unique XML streaming architecture boosts performance by “pre-processing” inbound XML documents before transmission of the document is complete.
For process modeling, the Eclipse-based IDE was not bad. Its graphical interface offered a pallet of drag-and-drop components for assembling processes and let me test the flows between my circuits before they were deployed. The capability to simulate run-time testing within the development environment sped up debugging tremendously. On the downside, I could not perform debugging during true run time, nor could I manually intervene in live processes. These would be nice improvements to PolarLake’s activity monitoring.
PolarLake’s newly added BPEL engine enables sophisticated exception handling, transaction compensation (rollbacks, alerts, and workflows in response to failed transactions), and message correlation (re-syncing a stream of messages for continued processing). Data transformation was standard stuff, although the graphical interface quickly became cluttered when handling anything beyond a one-to-one mapping. Transformation and content-based routing are strong thanks to XPath and newly added XQuery support.
On the development front, PolarLake’s biggest shortcoming is limited support for WS-* standards, but there are others. For example, you get no tools for tackling complex, non-XML-ready data structures. Incorporating Excel docs in processes won’t go as easily as with Cape Clear. Convoluted pop-ups in the new WSDL editor had me pining for a simple text editor.
Security, too, could use some improvement. PolarLake’s SecureXML module, which provides basic public key support for XML signatures and encryption, is a good step in the right direction, but the only adapter included is for the VeriSign Trust Service Integration Kit. For anything else, such as Baltimore’s KeyTools or Apache signatures, you’ll need to create your own adapters.
A basic management console, drawing on the sensor feedback data I built into my circuits, let me monitor and restart applications, as well as view error messages. I could not drill through to underlying specifics, making troubleshooting difficult, but remote monitoring and alerting — key to managing distributed services — were good. The system can generate SNMP traps to integrate with enterprise management systems.
Large customers may want a more complete toolset, richer activity monitoring, and fuller BPEL support from their ESB vendor, but the PolarLake Integration Suite has a lot going for it, including good process simulation, adapters for enterprise applications, and decent QoS provisions. Support for SWIFT, FIX, and XBRL document formats warrant a look from financial services companies.
Sonic SOA Suite 6.1
Sonic SOA Suite may be the most well-rounded and mature ESB solution in the marketplace today. This Java-powered package combines separate servers for the ESB, process orchestration, database services, and even XML processing. A separate product, the Sonic Collaboration Server, offers strong support for integrating external business partners.
Like Fiorano, Sonic lays a services bus atop its own messaging backbone, SonicMQ, to provide a cushion of reliability across transactions — raising the same concerns as Fiorano about vendor lock-in and the rigidity of centralized, heavy-duty hubs versus the more flexible, lighter-weight distributed end points that are the hallmark of true SOAs.
Sonic’s CAA (Continuous Availability Architecture), a software-based approach to high availability and guaranteed message delivery, demonstrated good performance and fault tolerance in my tests. Although hardware clustering for load balancing is still supported, CAA can help reduce your reliance on costly hardware as a hedge against system failures.
Although I’d prefer to see a cross-platform IDE, I didn’t mind the Windows-only development kit. Sonic Workbench includes a UML-style interface for building and managing business process flows. Workbench does not support BPEL and lacks process simulation capabilities, but its process-orchestration capabilities hit the mark.
Workbench made easy work of developing complex routing scenarios, using XSLT for transformations and XQuery for content-based routing, in addition to its itinerary-based routing, using specified instructions within the document.
Sonic makes the movement from development to staging server to deployment a seamless process. I easily configured, deployed, and checked dependencies among services with little effort. A solid security foundation includes pluggable authentication and encryption options, as well as embedded RSA support, which can be uniformly implemented across multiple domains for completely federated management. Also, although the majority of Sonic’s adapters will require additional third-party expense, the company offers one of the best selections of tried-and-tested application, b-to-b, and transactional adapters I’ve seen.
This weekend's Windows 10 upgrade has users angry, and it's unclear if the ploy will continue
Here’s the best of the best for Windows 10. Sometimes good things come in free packages
Speaking at the O'Reilly Fluent conference, Eich also endorsed the Service Workers mobile app...
Making the switch to Salesforce’s ecosystem can prove lucrative for biz-savvy programmers
A chat with IT consultant and former InfoWorlder Bob Lewis leads to a couple of entertaining...
Secure messaging apps are all the rage, and developers can now develop their own open source Wire...