1 Reply Latest reply on Sep 25, 2006 10:00 AM by Kurt Stam

    Progress on architecture updates

    Mark Little Master

      Esteban, Arvinder and I have been making good progress on the
      migration of the current codebase towards some of our goals with the
      original architecture, namely the support for EPRs (thanks to
      Arvinder for the schemas) and Messages. This is all in the
      'rearchitecture' branch. So far we have agreed on the message
      structure: header, context, body, attachment, fault and properties (a
      recent addition) and we have support for two external serialization
      formats: XML and Java Object Serialization. There is also support for
      dynamic serialization via plugins, so if these two implementations do
      not match user requirements they can change them. Plus, common has
      been renamed rosetta!

      All of the new code has been tested via Unit tests and QA tests and
      we've worked to keep the code coverage high. However, so far we have
      not integrated this new code with the ESB, i.e., it's really just a
      parallel development within the same source tree. Making the existing
      Rosetta code use the new Message and EPR approach is next on the
      list, although from speaking with Esteban it looks like we may need
      to merge some of Tom's recent changes into the branch first.

      My intention is that once we have moved the listener and action
      framework to use the Message and EPRs, we'll merge the branch into
      the trunk and everyone can work with the new approach. Meanwhile,
      we'll then start work on adding in the dispatchers. With any luck,
      that addition will be slightly easier to make than what we've been

        • 1. Re: Progress on architecture updates
          Kurt Stam Master

          Mughdo and I have been working on a registry design and implementation.
          We have explored two types
          of registries, ebXML and UDDI (see also the wiki:
          and have looked at one JAX-R implementation (Scout).

          You will be able to interact with the registry service in the ESB using
          the JAX-R API. A bootstrap process
          determines to what XML-Registry you are actually talking to, and what
          protocol is used (SOAP, RMI, local calls).
          So you can configure the ESB to use an existing XML repository. However,
          out of the box, we need our own repository.
          An embedded XML-Registry is the lightest possible implementation (no
          SOAP stack). Since JBossAS already
          picked jUDDI as their XML-Registry, it seemed a good option for us to do
          the same, if it could support what
          we wanted. However we also looked at freebXML. It turned out jUDDI
          almost could do what we wanted. We have submitted a patch to scout
          (http://issues.apache.org/jira/browse/SCOUT-18) and a patch to jUDDI
          (http://issues.apache.org/jira/browse/JUDDI-90) to enable the support
          local calls. The entire suit of scout unittest runs using the
          LocalTransport implementation. It should not be hard to add RMI support.
          I'm basically hoping we can simply use some EJB3 annotations in the
          classes that currently handle the local transport.

          Currently we are working on writing up some stuff on the bootstrap
          process, so you should see stuff showing up on the
          forum soon. After we have the bootstrap process stuff done, we will
          check it in along with the patched scout and juddi jars and a
          juddi.properties config file and some ESB specific unittests.