Proposal : Integrator HUB

Draft Owner: Ajitesh Das
                      ajitesh_das@yahoo.com

Overview

This document explains, integrator hub, a data/content  utility. In the environment of enterprise systems, it is
necessary to exchange data/content amoug hetrogenious data sources and sinks either in batch mode or in realtime mode.
In real world scenario, these integration becomes nightmare due to the differences  of data descriptions or schemas of
hetrogenious data sources and sinks.The integration hub, resides in the middle of the exchanging parties, transcodes content
from souce schema to destination schema. It also provides a hub-and-spoke middle-tier to eliminate peer to peer transcoding
redundencies.

Definations

The integrator hub consists of seven major components. These are as follows.

InputTranscodeFactory

This is a factory module, produces input transcoding object instances. Depending on the input schema type, this factory looks up
the registered transcoding object and instanciate for transcoding the input schema.
 

InputTranscoder

This is an abstruct component. This helps an application developer to build a custom InputTranscoder for transcoding his
custom input schema into internal data format. This also defines the XML schema generator utility routins for internal data
representation.
 

Rule Engine

This component identifies the transcoding rules for input contents from source to destination.It provides a python shell  based
API to application developer for generating custom transcoding rule.
 

OutputTranscodeFactory

This is also a factory module, produces output transcoding instances. Depending on the output schema type, this factory looks up
for the registered transcoding object and instanciate for transcoding the output schema.
 

OutputTranscoder

This is also an abstract component. This helps an application developer to develop a custom OutputTranscoder for transcoding
the content from internal data format, which is XML schema based format, to custom output schema format. This also defines couple
of XML schema routines to manipulate the content, represented in XML schema format.
 

RegisterAndConfigurator

This provides an application developer to register his custom InputTranscoder and OutputTranscoder. It also allows the user to
configure the integrator hub for trancoding utility.
 

ContentChannelManager

This component manages the input to output data channels.It is also responsible for translating data using registered custom
translating rules.(See rule engine ) It uses Input and Output Transcoder to parse and regenerate translated output data.
 

Data Flow And Transformation

The following figure shows the data transformation:

System Architecture

The system, integrator hub tool, achitecture is as follows:

Component Functionality

InputTranscoderFactory:

  1. Register custom InputTranscoder schema
  2. Instanciate (Singleton ) InputTranscoder obj

InputTranscoder:

  1. Provide mapping rules : Input Schema -> XML Schema (Internal format)
    For eg : a relation algebra to xml schema notation
 

                Lets assume a table EMP = Employee(name, age, Address )
 

                                                will be translated to

 <xsd:schema xmlns:xsd="http://www.w3.org/2000/08/XMLSchema">
    <xsd:annotation>
       <xsd:documentation>
         Relation Algebra to XML schema Translation example.
         Copyright 2000 Ajitesh Das.
      </xsd:documentation>
    </xsd:annotation>

   <xsd:element name="Employee" type="EmployeeType"/>
   <xsd:complexType name="EmployeeType">
     <xsd:sequence>
       <xsd:element name="name" type="xsd:string"/>
       <xsd:element name="age" type="xsd:integer"/>
      <xsd:element ref="address" default="null" type= "xsd:string"/>
    </xsd:sequence>
 </xsd:complextype>

     </xsd:schema>

Rule Engine:

  1. Register transcoding scheme ( as a python script )
  2. Invoke on XML internal schema


   For eg the script :
   class XMLTranscoderRule:
 
    ::::::::::::::::::::::::::::::::::
        def setInputElement(self,'name'):
            self.element = eleName
        def setOutputElement(self, seqName )
            #.......
            self.seqName [0] = seqName [0] # "FirstName"
            self.seqName [1] = seqName [1] # "LastName"
        def apply(self):
                        # split first name and last name
                        self.seqData[0] = first part of name
                        self.seqData[0] = last part of name
 
        This will change the XML schema from above to :
 

 <xsd:schema xmlns:xsd="http://www.w3.org/2000/08/XMLSchema">
    <xsd:annotation>
       <xsd:documentation>
         Relation Algebra to XML schema Translation example.
         Copyright 2000 Ajitesh Das.
      </xsd:documentation>
    </xsd:annotation>

   <xsd:element name="Employee" type="EmployeeType"/>
   <xsd:complexType name="EmployeeType">
     <xsd:sequence>
       <xsd:element name="FirstName" type="xsd:string"/>
       <xsd:element name="LastName" type="xsd:string"/>
       <xsd:element name="age" type="xsd:integer"/>
      <xsd:element ref="address" default="null" type= "xsd:string"/>
    </xsd:sequence>
 </xsd:complextype>

     </xsd:schema>
 

OutputTranscoderFactory:

  1. Register custom OutputTranscoder schema
  2. Instanciate (Singleton ) OutputTranscoder obj

OutputTranscoder:

  1. Provide mapping rules : XML Schema (Internal format)  -> Input Schema
    For eg :  xml schema notation to a relation algebra
   The above schema : translate :
           EMP = Employee(FirstName, LastName, age, address ) relational table
 

RegisterAndConfigurator

  1. Provide persistant registration of custom schema
  2. Provides utility configuration

ContentChannelManager

  1. Read Data
  2. Lookup for InputTranscoder
  3. Translate Schema -> XML
  4. Apply Rule set
  5. Translate XML -> Schema (output)

Class Diagrams

TBD.................
 
 

Event Diagrams

TBD.............