2008 IEEE International Symposium on Service-Oriented System Engineering

A Black-Box Strategy to Migrate GUI-Based Legacy Systems to Web Services Bo Zhang, Liang Bao, Rumin Zhou, Shengming Hu, Ping Chen Software Engineering Institute, Xidian University, Xian, China {jefferyzb, baoliangbox}@gmail.com {gmqin, shmhu}@mail.xidian.edu.cn [email protected]

Abstract

changing. If the migration approach costs too much time on reverse engineering of the legacy system, an organization might find itself with a redeveloped system based on obsolete technology that no longer meets its business needs. Thus, a black-box migration strategy is expected that avoids decomposing the legacy system and is also reusable for all legacy systems. Additionally, migration of GUI-based legacy systems are also threatened with reengineering complicated and indeterminate GUI interoperations between the systems and random users. Theoretically, a key problem in this domain is how to achieve a balance between the accessibility of legacy interfaces and decoupling the migration strategy from a specific legacy system.

While legacy systems are becoming incompatible with evolving web service applications, migration of legacy systems towards service-oriented computing is arousing wide concern for the purpose of salvaging the past investments on those systems. In this paper, a black-box strategy is proposed to export customized interactive functionality of legacy systems towards web services using a wrapping methodology suitable to GUI-based legacy systems. Our strategy also proposes a solution to deploy web services that consist of interoperations between user and legacy systems in a service-oriented architecture. Finally, a distributed framework that executes web services and integrates graphical user interfaces of legacy systems is presented.

As a matter of fact, a number of proposals on legacy system migration have emerged in the literature. For example, J. Bisbal states the issue of legacy system modernization and defines several general solutions in the problem domain with elaboration of their feasibilities. A black-box approach is presents in [8] to migrate interactive legacy systems towards Web Services based on a service wrapper using the Finite State Automaton theory [9]. Another serviceoriented approach is proposed in [28] to migrate legacy systems towards heterogeneous clients with service abstraction and adaptation techniques. To the best of our knowledge, almost all the migration approaches coping with GUI-based legacy migration are dependent on interface identification and certain mapping techniques to a new platform that cannot reuse the legacy interfaces.

1. Introduction A legacy system is traditionally developed with a centralized, mainframe-based and non-extensible architecture, representing a massive, long-term business investment. However, the increasing interest in Service-Oriented Computing (SOC) requires new access techniques for flexibly exploiting legacy functionality as Web Services. While other modernization approaches such as redeveloping another system with new interfaces are either unacceptable or too risky, a promising solution, legacy system migration, intends to deploy the legacy system into a different computing environment, whereas reusing as much of the system as possible, including implementation, design, interface, and specification. Nowadays major incompatibility of legacy systems lies in their obsolete non-extensible software architecture that has hampered legacy systems from modernization evolvements. In particular, many legacy systems are nondecomposable as black boxes to users for commercial consideration, making the modernization task even more challenging. Another very real concern stems from the fact that technology and business requirements are constantly

978-0-7695-3499-2/08 $25.00 © 2008 IEEE DOI 10.1109/SOSE.2008.8

In this paper, we propose a black-box strategy to migrate a GUI-based legacy system towards Web Services. The legacy interfaces are reused and integrated into our framework to minimize coupling with a specific legacy system and to avoid decomposing the internal components. To make legacy applications accessible in a distributed network, a Virtual Network Computing (VNC) [19] tool is employed and wrapped as a Web Service to remotely implement legacy functionality. Besides, a scripting language, Lua [17], is also exploited to intelligently execute auxiliary GUI operations on behalf of users. Due to the loose coupling with legacy systems, the migration strategy can be ap-

25

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

plied flexibly to most GUI-based legacy systems, and it has already been validated on several mainstream tools. As to the organization of the paper, section 2 describes the migration approach with elaboration of the framework, while section 3 presents a case study. Related works are presented in section 4 and finally, in section 5, conclusion and future works are discussed.

2

Migration Strategy

The migration strategy we propose is involved with a hybrid of remote control and service wrapping techniques as well as a dynamic scripting language. A framework is implemented on the basis of Service-Oriented Architecture (SOA). An overview of the architecture framework is presented as follows with elaboration of its core modules.

2.1

Figure 1. Migration Architecture. systems right into a service-oriented framework. Theoretically, the integration approach using a window embedding technique is a thorough ”black-box” reengineering task in which not only the legacy system internals but also the GUI components of the legacy system are ignored. Moreover, according to our modernization approach, the demonstration of original legacy interfaces maintains system usability and makes no difference to the experience of users. To make a legacy system accessible as a Web Service, it is required that its interface is adapted to the distributed interaction paradigm of Web services. One major restriction of legacy systems is that the legacy applications are isolated and incompatible to be accessed remotely in the Internet. Our solution to this issue is to provide remote control capability with Virtual Network Computing (VNC) technique.

Architecture Overview

Figure 1 demonstrates a Service-Oriented Architecture (SOA) that implements our black-box strategy to migrate a GUI-based legacy system towards Web Services. The framework logically contains a service provider and a service requester. A service requester invokes and executes Web Services from its local service container that a service provider has published. Web Services are required to be wrapped and deployed in service containers in advance. A service wrapper is involved in each terminal in order to guarantee that heterogeneous applications are accessible to Web Services. In the problem domain of legacy system modernization, key wrapping applications includes remote control and GUI operation executions that are supported by VNC [19] and Lua [17] as is illustrated in Figure 1. The composition service that is implemented by a BPEL [1] engine serves as the initiator of migration, and also handles orchestration of other services. Auxiliary services such as file listening are necessary during the migration process. The control flow conducts the execution of Web Services on the basis of network protocols and business process standards such as SOAP, WSDL [27] and BPEL [1].

2.2

2.2.1

Window Embedding

In this section, we integrate the graphical user interfaces into our framework with window embedding technique that is generally supported by API of mainstream operation systems. The windows of legacy systems that are supposed to be embedded are firstly identified by their intrinsic characteristics such as window captions or window class names, and then they are embedded into a parent frame and perform as child windows. Figure 2 illustrates a practical integration where both Rational Rose and Computer Associates ERwin are embedded into our framework as two GUI-based legacy systems. According to our implementation, a customized window organization for GUI display is supported especially when multiple child windows are embedded.

GUI Migration

In order to obtain the execution of a legacy system functionality including GUI interoperations, a pressing and stubborn question to be addressed for migrating the legacy system towards Web Services consists of providing accessibility of its graphical user interface into a distributed framework that is typical of service-oriented architectures. In contrast to previous works coping with migrations from GUI-based legacy systems towards another set of interfaces as in [8] and [28], the solution we propose contributes to reuse and integrate the graphical user interfaces of legacy

2.2.2

Remote GUI Control

A significant problem in the modernization of legacy systems is how to maintain interoperations between users and legacy interfaces that are required to be reengineered

26

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

Figure 4. Remote Access to Visual C++. Figure 2. Embedding Rose and ERWin.

2.3

Lua Application of GUI Operations

On basis of practical and theoretical experience in the problem domain, repetitive and verbose interoperations on GUI-based legacy systems bring considerable burdens to users. In this section, we propose to handle GUI operations with Web Services that can be executed on behalf of users. In our reengineering approach of legacy system migration, GUI operations are executed with an improved Lua [17] module that consists of a Lua interpreter, Lua scripts and extended APIs, as shown in Figure 5. To begin with, extended APIs are bound with the Lua interpreter. After that, the interpreter is competent to execute Lua scripts that invoke those extended APIs to implement GUI operations automatically.

and deployed in the Internet. Common techniques are often involved with decomposing and analyzing components of legacy interfaces as in [8] and [13]. However, those techniques will bring strong coupling between migration tools and legacy systems with tremendous complexity attributed to potential composition of interoperations in GUI-based legacy systems, not to mention the difficulties in nondecomposable legacy sysems. Therefore, we propose Virtual Network Computing (VNC) technique to share the accessibility of GUI-based legacy systems with remote users. As is illustrated in Figure 3, a VNC tool consists of a server that shares its authority of the operation system and a viewer that is authorized to control the server. In a VNC connection, images of the server screen are compressed and transmitted to the viewer, while control information of the viewer is transmitted to the server to be remotely executed. Additionally, data encryption is employed for network communication.

Figure 5. Lua Module. Figure 3. VNC Server and Viewer.

2.3.1 Figure 4 demonstrates a remote control of Microsoft Visual C++ by an open source tool called TightVNC that is integrated into our framework. At present, TightVNC supports remote control between different operation systems including Windows, Linux, etc.

Lua Interpreter Customization

Lua is a powerful, light-weight scripting language that is designed to support both general procedural programming with data description facilities and also object-oriented programming. Lua scripts are driven by an interpreter that is implemented as a library, written in ANSI C. Hence, APIs

27

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

written in C/C++ can be bound with the Lua interpreter in order to extend its functionality. In the modernization task of executing GUI operations with pieces of Lua code, auxiliary functions are augmented to simulate human interoperations on legacy systems. Since the interface of legacy systems are not available in a blackbox circumstance, the APIs integrated into the Lua interpreter are oblivious of specified legacy interfaces, but rather in terms of the operation system level, such as the window embedding application mentioned above and applications that call mouse and keyboard operations.

2.3.2

Lua Scripts

A Lua script involved in our framework is firstly loaded and then executed by the Lua interpreter. Due to the flexibility of Lua language, complicated logic of GUI operations is supported intelligently with Lua scripts. Also, parameters are enabled to be transmitted from the Lua interpreter into Lua scripts. Moreover, auxiliary APIs in ANSI C are introduced in Lua scripts to implement GUI operations. In fact, the Lua scripting language is required and irreplaceable in our framework due to its innate viscidity with ANSI C. Figure 6 is a Lua script implementing the operations of opening a given file in Rational Rose. The file name will be transmitted into the script as a service parameter. The function ”rcRun” in line No.8 executes the path of Rational Rose and embeds the Rose window into our framework. Line No.19 simulates keyboard events of hotkey F and O to invoke the open-file dialog. After the file name is entered in the dialog, an enter key is pressed to open the given file.

2.4

Figure 6. A Lua Script.

script that invokes a Lua interpreter to execute the Lua script.

Service Wrapping

In this section, a wrapper is presented to guarantee that all applications involved in the migration of legacy systems are accessible to Web Services. Wrapped Services in our framework consists of GUI operation services, VNC services and other services shown above in Figure 1. Practically, the wrapper is associated with a Python engine to invoke different kinds of services in the run-time without compilation. A Web Service is wrapped as a Python script accessible to the service container and a WSDL [27] file that describes the interface and the location of the service. Figure 7. GUI Operation Service.

2.4.1

GUI Operation Service

GUI operations are wrapped into Web Services that are placed in a service container. As shown in Figure 7, a Lua script that describes a set of GUI operations is required to be identified by the service wrapper that generates a python script and a WSDL [27] file. When the GUI operation service is requested, the service container executes the python

Figure 8 demonstrates the implementation of GUI operation service wrapping. After a Lua script directory is given, the script is validated and its parameters are identified if any. At the end of the wrapping process, a python script file is generated as shown in Figure 9. The python script is the core entity of a Web Service in our implementation.

28

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

mission between service providers and requesters in a network.

3

Case Study

In this Section, a case study is presented to demonstrate the feasibility of the proposed migration strategy. A practical migration scenario is devised where the involved GUIbased legacy systems are Rational Rose and Computer Associates ERwin. Rose is a well-known modeling software that allows a user to design UML diagrams, while ERwin aims at reverse engineering database models. Admittedly, it is a black-box migration since neither of the two legacy systems is decomposable.

Figure 8. GUI Operation Wrapping.

Figure 9. Wrapped Python Script.

2.4.2

Remote Control Service

VNC software is required to be wrapped as a Web Service to support remote control of GUI-based legacy systems. According to our implementation, the operation of VNC connection is composed in a Lua script and wrapped as a GUI operation service. To be specific, the VNC connecting operation mainly contains inputting the IP address of the VNC server and pushing the confirming button. However, since VNC Tools such as TightVNC are open-source, these operations can also be redeveloped as a specific Web Service.

2.4.3

Figure 10. Sequence Diagram of Service Execution. In the proposed scenario, a user needs to design a class diagram with Rose in the first place, and then he needs to create a database according to the class diagram using ERwin. Unfortunately, neither of the two legacy systems is deployed in the user’s machine. Therefore, both of the legacy systems are required to be migrated to Web Services with our black-box migration strategy, and then they are feasible to satisfy the user’s requirement. As shown in Figure 10, the user remotely controls the Rose VNC server to design a class diagram through a VNC connection. After that, the class diagram is transmitted back to the user as a VNC viewer, where the diagram is transformed into a SQL script file. Finally, the SQL file is transmitted to another ERwin server, and a Lua script will be involved to execute a

Other Services

Other services are necessary to enhance the migration of legacy systems. One indispensable service is the composition service that orchestrates any other services, implemented by a standard BPEL [1] engine. A file listening service is presented to listen given file and perform file trans-

29

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

batch of GUI operations automatically to create a datebase according to the SQL script. The ERwin interactions are supervised by the user via a VNC connection. In reality, each action in Figure 10 is composed and executed as a Web Service, driven by a standard BPEL engine such as ActiveBPEL. Figure 11 illustrates the BPEL process that orchestrates all necessary services in the scenario. Web Services are deployed in distributed service containers that are integrated in our framework. The practical performance of legacy applications is similar to the demonstration in Figure 2, where the interfaces of Rose and ERwin are reused.

In contrast with white-box approaches that can only be implemented in very ideal cases, different is the approach of black-box techniques that, instead of analyzing the application code, but considers the inputs and outputs during the user interaction with the system to gain an understanding of the system interfaces. Examples of these techniques are described in [24] where an interface mapping method is proposed for the reverse engineering of legacy system user interfaces. This method is based on screen identification and on the tracing of user interactions with the system. [14] presents a black box reverse engineering approach for dynamic Web Applications based on hypertext markup languages. As to the problem of exporting a legacy application towards the web services world, a few proposals have been presented in the literature. [28] proposes a reengineering task to migrate legacy systems towards heterogeneous clients with service abstraction and adaptation techniques. Unfortunately, it belongs to the white box family that stems from the legacy systems’ APIs. In contrast, a black-box strategy is presented in [8] that exploits the theory of Finite State Automaton to wrap legacy applications as Web Services. However, a potential risk is that the feasibility of state identification depends on the complexity of legacy interfaces. In extreme cases, state explosion may complicate the migration issue into an NP complete problem. Moreover, both of [8] and [28] cannot reuse the interface of legacy systems, and also imply a negative risk of excessive coupling between legacy systems and resulting systems.

5

Figure 11. BPEL Process.

4

Conclusion and Future works

In this paper a migration strategy for exporting the functionality implemented by a legacy System as a Web Service has been presented. The approach is tailored for GUI-based systems, whose interfaces are reused and integrated into a service-oriented framework. A framework has been implemented with the migration strategy based on the ServiceOriented Architecture. A strength of this approach is the service wrapper that encapsulates heterogeneous applications oblivious of the specific legacy system, making it a black-box reusable implementation. In this way, the approach allows users to seamlessly interact with the GUIbased legacy systems as before. Meanwhile, GUI operations can also be composed in a Lua script and be executed as a Web Service automatically. Future work will be devoted to coping with concurrent request of legacy applications and involved potential competitions for exclusive accessibility. Since the legacy systems are very likely to be non-extensible, one possible solution is to dynamically clone legacy applications for service requesters. Another interesting future work will consist of implementation of a GUI operation recorder that in-

Related Works

The problem of Legacy System Modernization is not novel in the literature, where a number of approaches can be found. A taxonomy of Legacy System Modernization techniques distinguishing between redevelopment, wrapping and migration techniques is presented by [2], in which redevelopment is unacceptably risky and wrapping is unsuitable, while migration is a feasible option. From another perspective, legacy system modernization techniques may also be subdivided into White Box and Black Box families, where the first family is based on the source code redevelopment, while the second one does not require the analysis of the code as in [13]. As to the problem of migrating the interface of a legacy system towards new platforms, most of them are white box approaches, based on reverse engineering techniques that aim at decomposing the legacy system and extracting its interface components and application components through code analysis as in [18, 15, 20].

30

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.

telligently identifies customized GUI operations into a Lua script so as to facilitate the generation of Lua scripts.

References [1] Business Process Execution Language for Web Services. http://www.ibm.com/developerworks/library/specification/wsbpel/, July 2002. [2] J. Bisbal, D. Lawless, B.Wu, and J.Grimson. Legacy information systems: issues and directions. IEEE Software, 16(5):103–111, Sept.-Oct. 1999. [3] D. Bovenzi, G. Canfora, and A. Fasolino. Enabling legacy system accessibility by web heterogeneous clients. In Proceedings of the 7th European Conference on Software Maintenance and Reengineering, pages 73–81. IEEE, 2003. [4] G. Canfora. Software evolution in the era of software services. In Proceedings of 7th International Workshop on Principles of Software Evolution, pages 9–18. IEEE, 2004. [5] G. Canfora, A. Cimitile, F. Garcia, M. Piattini, and C. Visaggio. Performances of pair designing on software evolution: a controlled experiment. In Proceedings of 10th European Conference on Software Maintenance and Reengineering, page 8. IEEE, 2006. [6] G. Canfora, A. Cimitile, A. D. Lucia, and G. D. Lucca. Decomposing legacy programs: A first step towards migrating to client-server platforms. In Proceedings of 6th IEEE International Workshop on Program Comprehension, pages 136– 144. IEEE, 1998. [7] G. Canfora, A. Fasolino, G. Frattolillo, and P. Tramontana. A flexible wrapper for the migration of interactive legacy system to web services. In Proceedings of 10th European Conference on Software Maintenance and Reengineering, page 2. IEEE, 2006. [8] G. Canfora, A. R. Fasolino, G. Frattolillo, and P. Tramontana. Migrating interactive legacy systems to web services. In Proceedings of the 10th European Conference on Software Maintenance and Reengineering, page 10. IEEE, March 2006. [9] G. Canfora, A. R. Fasolino, G. Frattolillo, and P. Tramontana. A wrapping approach for migrating legacy system interactive functionalities to service oriented architectures. Journal of Systems and Software, 81(4):463–480, Apr. 2008. Elsevier Science Inc. [10] G. Canfora, A. D. Lucia, and G. D. Lucca. An incremental object-oriented migration strategy for rpg legacy systems. International Journal of Software Engineering and Knowledge Engineering, 9(1):5–25, Feb. 1999. World Scientific Publishing Company. [11] K. Chan, Z. Cong, L. Liang, and A. Michail. Design recovery of interactive graphical applications. In Proceedings of the 25th international conference on Software engineering, pages 114–124. IEEE, 2003. [12] A. Cimitile, U. D. Carlini, and A. D. Lucia. Incremental migration strategies: Data flow analysis for wrapping. In Proceedings of 5th IEEE Working Conference on Reverse Engineering, pages 59–68. IEEE, 1998.

[13] S. Comella-Dorda, K. Wallnau, R. Seacord, and J. Robert. A survey of black-box modernization approaches for information systems. In Proceedings of the International Conference on Software Maintenance, pages 173–183. IEEE, October 2000. [14] D. Draheim, C. Lutteroth, and G. Weber. A source code independent reverse engineering tool for dynamic web sites. In Proceedings of Ninth European Conference on Software Maintenance and Reengineering, pages 168–177. IEEE, 2005. [15] Y. Gaeremynck, L. Bergman, and T. Lau. More for less: Model recovery from visual interfaces for multi-device application design. In Proceedings of the 8th ACM Int.Conf. on Intelligent User Interfaces, pages 69–76. IEEE, 2003. [16] R. Ierusalimschy. Programming in Lua. Lua.org, 2nd edition edition, 2006. [17] R. Ierusalimschy, L. de Figueiredo, and W. Celes. Lua 5.1 Reference Manual. Lua.org, 2006. [18] E. Merlo, P. Gagn, J. Girard, K. Kontogiannis, L. Hendren, P. Panangaden, and R. D. Mori. Reverse engineering and reengineering of user interfaces. IEEE Software, 12(1):64– 73, 1995. [19] T. Richardson, Q. Stafford-Fraser, K. Wood, and A. Hopper. Virtual network computing. IEEE Transactions on Internet Computing, 2(1):33–38, Jan-Feb 1998. [20] S. Rugaber. A tool suite for evolving legacy software. In Proceedings of IEEE International Conference on Software Maintenance, pages 33–39. IEEE, 1999. [21] H. Sneed. Accessing legacy mainframe applications via the internet. In Proceedings of 2nd International Workshop on Web Site Evolution, pages 34–46. IEEE, 2000. [22] H. Sneed and S. Sneed. Creating web services from legacy host programs. In Proceedings of the 5th IEEE International Workshop on Web Site Evolution, pages 59–65. IEEE, 2003. [23] H. Sneed and S. Sneed. Reverse engineering of system interfaces a report from the field. In Proceedings of 13th Working Conference on Reverse Engineering, pages 125–133. IEEE, 2006. [24] E. Stroulia, M. El-Ramly, L. Kong, P. Sorenson, and B. Matichuk. Reverse engineering legacy interfaces: An interaction-driven approach. In Proceedings of the Sixth IEEE Working Conference on Reverse Engineering, pages 292–302. IEEE, 1999. [25] E. Stroulia, M. El-Ramly, and P. Sorenson. From legacy to web through interaction modeling. In Proceedings of International Conference on Software Maintenance, pages 320– 329. IEEE, 2002. [26] S. Tilley, J. Gerdes, T. Hamilton, S. Huang, H. Muller, and K.Wong. Adoption challenges in migrating to web services. In Proceedings of the 4th International Workshop on Web Site Evolution, pages 21–29. IEEE, 2002. [27] World Wide Web Consortium, http://www.w3.org/TR/wsdl. Web Service Description Language (WSDL) 1.1, January 2006. [28] U. Zdun. Reengineering to the web: A reference architecture. In Proceedings of 6th European Conference on Software Maintenance and Reengineering, pages 164–173. IEEE, March 2002.

31

Authorized licensed use limited to: Technische Universitat Kaiserslautern. Downloaded on April 26, 2009 at 12:03 from IEEE Xplore. Restrictions apply.