THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
Synapse and Tuscany 1 day track
Target Audience
The Synapse / Tuscany Track at ApacheCon US will cover the two key SOA technologies. Synapse is a lightweight ESB and message broker, and Tuscany is an SCA runtime. The sessions will cover design and architecture of the OSGi based Tuscany SCA Runtime, various aspects of building applications with Service Component Architecture (SCA), and how to use the Synapse ESB to effectively mediate, route and transform messages across a Service Oriented Architecture. These talks are intended for technology enthusiasts as well as for Developers and CTOs interested in learning more about SOA, SCA and ESBs and how these technologies can help when implementing flexible enterprise solutions.
Abstracts
SCA, Java EE, Spring and Web 2.0 Come Together: Service assembly with Apache Tuscany SCA
Luciano Resende and Raymond Feng
Apache Tuscany provides an easy-to-use open source services infrastructure for building, assembling, deploying and running SOA solutions based on the Service Component Architecture (SCA) specifications from OASIS. The Apache Tuscany project goes beyond the SCA specification and is an environment for innovative ideas around SOA, for example it extends SCA to work with web2.0 and OSGI. Apache Tuscany is integrated with other Apache technologies such as Tomcat, Axis2, Geronimo, BSF, Ode, XMLBeans and Abdera.This talk will provide a short overview of SCA and the Apache Tuscany project and will mainly focus on an enterprise integration example to demonstrate how to take advantage of SCA and Tuscany to describe, assemble and deploy an end-to-end SOA solution.
This talk is directed at those who are building distributed solutions from connected services and want to understand how SCA can help.
The presenters will use their experience of working with the Apache Tuscany project and its users to illustrate:
• Partitioning of the application into components and services
• Exploitation of a variety technologies to implement components including Java EE, Spring and Web2.0
• Use of different communication technologies such as web services, JSON-RPC
• Configuration of policy to control consistent quality of service across the distributed application
• Deployment to distributed runtimes with varying capabilities including Java EE containers, web browsers and command line JSE nodes
Distributed OSGi with SCA using Apache Tuscany
Raymond Feng and Luciano Resende
OSGi goes beyond service invocations in a single JVM with the introduction of RFC 119 - Distributed OSGi. It will enable an OSGi bundle deployed in a JVM to invoke a service (either OSGi or non-OSGi) in another JVM or process, potentially on a remote computer accessed via a network protocol. Meanwhile, an OSGi service deployed in another JVM or a non-OSGi program such as Web Service client, potentially on a remote computer, to find and access a service running in the "local" OSGi JVM (i.e. an OSGi deployment can accept service invocations from remote OSGi bundle or external environments). The distributed computing functionality is added to the OSGi programming model without additional APIs or concepts as the distribution layer will be mostly transparent to OSGi developers by configuration.
SCA (Service Component Architecture) provides a technology-neutral approach to abstract business logic into components and assemble them into composite applications. It greatly simplifies the component communications using declarative bindings. QoS requirements can be uniformly declared as SCA intents which can be mapped and realized using different stacks. SCA is a great fit to be a distribution provider for distributed OSGi.
Apache Tuscany is an open source project that implements the SCA specifications. It provides integrations of implementation types (such as Java, Scripting, BPEL, Spring, OSGi and JEE) and binding types (such as Web Service, JMS, EJB, CORBA, RMI, JSONRPC, and ATOM) as the infrastructure for SCA programming. The latest version of Tuscany runtime is fully built on top of OSGi as the foundation. We recently added the OSGi RFC 119 support.
In this session, we will teach you how to develop a distributed OSGi application to leverage the SCA capabilities using Apache Tuscany. A calculator scenario will be used to demonstrate the distributed OSGi service invocations using RMI and Web Service protocols. We will also explain how to model an OSGi bundle as an SCA component and configure the SCA composite to provide communications between services. The readers will understand the basic ideas behind distributed OSGi in the concrete example and the power of Tuscany SCA for service composition.
Tuscany: Applying OSGi modularity after the fact
Luciano Resende and Raymond Feng
Apache Tuscany is an open source project that simplifies the development, deployment and management of distributed applications built as compositions of service components.It is based on the Service Component Architecture specifications being defined by the OASIS Open SCA Collaboration. Tuscany was built with a modular architecture, using a different approach from that of OSGi. In 2008 an effort was started to integrate Tuscany with OSGi. As part of this we undertook an investigation into how to apply OSGi modularity to the Tuscany runtime so that clean boundaries between modules are enforced and different versions of the same library can coexist.This involved analyzing the existing Tuscany modularity which turned up lots of interesting information about the linkages between the various sub-components. This understanding was then used to determine how to map Tuscany into a suitable form for use as OSGi bundles, including prototyping various levels of decomposition granularity. This presentation will share the experiences of analyzing and modularizing an existing project using OSGi. It will discuss what to expect when approaching modularizing existing projects, the tools (and it's caveats) for aiding analysis and also best practices for applying OSGi modularity. Beyond the OSGi enablement for the runtime, we are also going to cover how to integrate OSGi and SCA at the application level.
Synapse: Event Driven Architectures with Apache Synapse
Paul Fremantle
Event Driven Architecture (EDA) is a highly scalable approach for
building large scale distributed applications and integrating across
large organizations. In an EDA, many systems can manage their own
destiny in connecting to the rest of the applications, and this
approach means that new applications can be much more self-reliant.
EDA has been widely adopted in the financial sector, but is gaining
ground in many other areas. This presentation will introduce EDA and
the benefits, challenges and best practices for building EDA, and also
show how to architect real-life EDA systems. In addition, we will
explore Complex Event Processing, which adds a whole new set of
capabilities to find patterns, react in real time to data, and
correlate across high volume data feeds. In addition, we will look in
detail at how the Apache Synapse ESB can be used to build an EDA, both
by itself and in conjunction with other projects such as Apache Qpid
and ActiveMQ. We will examine how to build topic spaces, create
routing and subscription patterns, and how to add Complex Event
Processing to an EDA. This talk is aimed at coders and system
architects who want to understand how event architectures can improve
their systems and how to use Apache technology to build them.
Integration made simple with the Synapse ESB
Asankha Perera
The Apache Synapse Enterprise Service Bus (ESB) is a lightweight and high
performance ESB, which is designed to be simple to use and manage. The ESB
is configured via a simple human readable configuration file, and can be
managed via JMX for management and monitoring. It provides support for fully
non-blocking http/s based on the Java NIO extensions of the Apache
HttpComponents project, and thus can manage thousands of concurrent
connections with standard hardware. It also support transactional JMS, File
systems based on Apache VFS, Mail, FIX etc, and supports multiple message
formats, with support for extension. This presentation introduces the
Synapse ESB, and how one can immediately make use of it to fulfill
integration requirements of an enterprise. We will look at some sample
scenarios and how they are made possible with ease, using the Synapse ESB
*Achieving Scalability and High Availability for clustered Web
Services using Apache Synapse*
Ruwan Linton, Paul Fremantle
This will give an insight on how you can use Apache Synapse mediation
framework to guarantee the scalability and availability of hosted services.
It requires a cluster of services to be available and Synapse will balance
the load and fail over route the messages among the cluster of services to
provide scalability and availability. Apache Synapse is designed to be a
simple, lightweight and high performance Enterprise Service Bus (ESB). Since
it is based on a small asynchronous core, it can handle 2500 concurrent
connections on a standard server hardware. The Synapse engine is configured
with a simple XML format and comes with a set of ready-to-use transports on
which it can be used as a load balancer and a fail over router. Synapse
supports static and dynamic load balancing, static load balancing can be
used when you have a set of known hosts in the cluster where as dynamic load
balancing could be used for an environment where the nodes on the service
cluster is dynamic for example when auto scaling of the service cluster is
active. In the case of dynamic load balancing the load balance endpoint gets
the list of nodes which provides this service from the underlying Group
Communication Framework of the cluster. Apache Synapse can be used for
general mediation tasks while providing the scalability and availability to
a set of services as well. You may use Synapse to log the messages coming
into your network or to throttle the messages to your services.