1. Exception Handling in Component – Based Software Systems
TERM PAPER
(CSC 532:Adv. Topics in Software Engineering; Fall – 2003)
- By Rahul Goutham Gundala.
Louisiana Tech University

2. Introduction What is Component Based Software Development?
The problems of CBSD.
Proposed Solution.

3. Frame Work
Create wrappers that perform local error detection and exception handling.
Identify atomic actions in which components take part and configure the system.
Design action level exception handling for integrated system.

4. Exception Handling Exception: An unusual event in the program.
Exception handling: Structuring mechanism to distinguish b/n normal and abnormal behavior in system.
Two types: Internal and External.

5. Local Error Detection and Exception Handling
Designed for each component in the system.
Looks as follows:
W  Wrapper
C  Component
Incorporate damage assessment.
Try to handle exception locally at the standard interface.
Signal all exceptions in a unified manner to the environment.

6. Atomic Actions
Are structuring units which hide intermediate steps of state and behavior changes.
They create the dynamic system behavior.
Actions can be nested so that they structure recursive systems.
No information is allowed outside the action boundary.
They provide fault tolerance for handling hardware faults, design faults, transient faults and environment faults.

7. Integrated System from Atomic Actions
Atomic actions form sound basis for integrated system as they support recursion.
Several participants enter and leave actions as below:
If local handling does not succeed then the exception is propagated to the Action level from the inner components.

8. Action oriented Exception Handling
Several components can be combined as below to form actions:
When an error is detected all participants are involved in the action level exception handling as the local exception handling cannot resolve the problem.
Action level recovery suits well to recovering component systems because the component results are usually committed and it is not always possible to abort them, so there is a need in using system level compensation.

9. Proposed Implementation
Local error detection and handling are implemented as component wrappers.
The wrapping technologies are termed interceptors in CORBA and DCOM+, and proxies in CORBA3 and Enterprise JavaBeans.
…contd

10. Proposed Implementation
In CORBA the integrated system can be designed as follows:
Many other languages like Ada, Java, CSP, OCCAM also support the implementation of wrappers.

11. Conclusion
Describes about a framework for embedding structured exception handling into component-based system development that relies on two level exception handling: the component level and the integrated system level.
Highlights local error detection as a part of the framework and discusses the specific sources of errors to help in developing software to perform this functionality.
Proposes an idea of developing local error detection and local exception handling using the existing wrapper techniques.
...contd

12. Conclusion
Outlines a schematic approach to designing wrappers incorporating local error detection and exception handling.
Advises of using the well-established concept of atomic actions to structure integrated systems and to incorporate exception handling at the system level in a disciplined and systematic way.
Emphasizes possible approaches to implementing the framework support within the standard component technologies.

13. References
R.H. Campbell, B. Randell. Error Recovery in Asynchronous Systems. IEEE TSE-12, 8 (1986)
A.Romanovsky, A.F. Zorzo. On Distribution of Coordinated Atomic Actions. ACM Operating Systems Review, 31, 5 (1997)
F. Cristian. Exception Handling and Tolerance of Software Faults. In Software Fault Tolerance, Lyu, M. (ed.). Wiley (1995)
Romanovsky, A., Exception handling in Component Based systems., 2001, University of New Castle, UK .