A Systematic Design Automation Method for RDA-based .NET Component with MDA

Abstract

Recent Enterprise System has component driven real-time distributed architecture (RDA) and this kind of architecture should performed with satisfying strict constraints on life cycle of object and response time such as synchronization, transaction and so on. Microsoft's .NET platform supports RDA and is able to implement services including before mentioned time restriction and security service by only specifying attribute code and maximizing advantages of OMG's Model Driven Architecture (MDA). In this study, a method to automatically generate an extended model of essential elements in an enterprise-system-based RDA as well as the platform specific model (PSM) for Microsoft's .NET platform are proposed. To realize these ideas, the functionalities that should be considered in enterprise system development are specified and defined in a meta-model and an extended UML profile. In addition, after defining the UML profile for .NET specification, these are developed and applied as plug-ins of the open source MDA tool, and extended models are automatically generated using this tool. Accordingly, by using the proposed specification technology, the profile and tools can easily and quickly generate a reusable extended model even without detailed coding-level information about the functionalities considered in the .NET platform and RDA.

1. Introduction

In recent years, business environments have become morecomplex, and therefore, enterprises need to be capable of flexible and agile response. In this context, a real-timedistributed architecture (RDA) is widely accepted as anarchitecture that supports enterprise systems [1]. In this type of architecture, time constraints and security services, such as object pooling, synchronization services, and transactionservices for object life cycle and response time, are essential [2]. Initial studies of OMG’s Model Driven Architecture (MDA) mainly focused on supporting various conversionformats and source code generation for various developmentlanguages. Recently, a method has been developed togenerate an extended model by applying the elements necessary for model extension from the basic model. However, it was limited to specific fields or specific tools such as embedded software, and it lacked model extensibility for the abovementioned time constraints.

Microsoft’s .NET platform supports RDA. It can be used to implement components that support services such as timeconstraints and security by simply specifying an attributecode in the source code. Therefore, the benefits of MDA can be maximized by using the .NET attribute code and Unified Modeling Language (UML) profile mechanism. However, compared to the meta-model and UML profile in Enterprise Java Beans [3], .NET is not yet established. Only a few studies have focused on the platform-specific model (PSM) specification technique for .NET.

In this study, the functional elements of various servicesthat should be considered for developing enterprise systems are specified and defined as a meta-model and an extended UML profile. In addition, after defining the UML profile for PSM specifications for .NET, these are developed and applied as plug-ins of StarUML [4], an open source MDA platform, and the design model is generated automatically. Therefore, even if we do not know detailed coding-levelinformation about the functions to be considered in the .NET platform and the RDA using the proposed specificationtechnique, profile, and tool, the roles of each element of the model must be defined. A reusable expansion model can be generated easily and quickly if an attribute value can be established according to the role. Because the proposed profile is an extension of OMG’s UML profile and MDA standard, it can be reused in several Meta Object Facility (MOF) [5]-compliant UML and MDA tools to increase the productivity, scalability, portability, and maintainability of the design model.

The remainder of this paper is organized as follows. Chapter 2 describes related research. Chapter 3 defines RDA-based service elements and their meta-model. Chapter4 defines the UML profile to which the specified service is applied, and it describes the model design process, presentation method, and transformation process using the defined profile. Chapter 5 describes case studies. Finally, Chapter 6 presents the conclusions of this study.

2. Related Works

2.1 UML Profile for EDOC

OMG proposed a UML Profile for Enterprise Distributed Object Computing (EDOC) for a distributed computingenvironment to express events, processing, entities, and patterns in the component architecture. However, it is difficult to express functions such as time constraints and security services such as object pooling, synchronizationservice, and transaction service. The main components of the UML Profile for EDOC are as follows.

First, Enterprise Collaboration Architecture (ECA) [6] is used for developing an EDOC system with a modeling framework. Second, UML Profile for Patterns [7] can express business function object patterns using UML packagenotation. Third, UML Profile for ECA provides specifications for entities, events, and business. Forth, the UML Profile for MOF specifies the mapping between UML and MOF. Finally, the UML Profile for Relationships specifies a standard for relationships in business models. Table 1 shows the element mapping for entities.

2.2 Wang’s Model to Model Transformation[8]

Wang proposed methods for automating model-to-model mapping and transformation to support model-based systemengineering. He defined model transformation rules for both semantics and syntax and described the mapping and transformation between models as a meta-model-based transformation process. In addition, the proposed tool canautomate model generation and testing using extended modeldesign capabilities with defined rules. However, the meta-model for the proposed technique and extended modelgeneration does not comply with OMG’s MOF standard, and thus, it lacks portability and interoperability. The detailed specification elements and supporting platform of PSM arenot mentioned.

2.3 .NET Attribute code

In the .NET platform, some specific form may be defined in advance and be used to control the run time motion; thisis called the “Attribute” code. The attribute class providesconvenient methods for testing the applicable characteristics and access to designate user. All attributes are directly orindirectly derived from the attribute, and the characteristics may be applied to all subject elements [9]. Figure 1 shows an example of specifying attributes for transactions, object pooling, Component Object Model (COM), and so on usingattribute codes in a minimal .NET class code. Attributes canalso specify security, synchronization, timely activation, and other factors.

(Figure 1) .NET Attribute code format

3. RDA Service Elements

We define a meta-model for functional elements that areconsidered essential for developing an RDA-based enterprisesystem. The application architecture is determined by the application requirements. In general, high-end enterpriseapplications require high scalability and stability for the basicuser experience; therefore, an RDA is selected for this purpose. These architectures inevitably use functions such assynchronization, transaction, object pooling, and security services depending on the object’s life cycle and responsetime [10].

A Serviced Component supports an RDA-based service, and the service elements mainly include remote access, instance management, transaction management, synchronization, persistence, and security services, as shown in Figure 2.

(Figure 2) RDA-Service meta-model

Remote access is a service that invokes an instance of alocally detached component to request the necessary functions. Instance management is a service that managesinstance activation/deactivation, pooling, and lifecycle. The class that wants to be a component supporting RDA-based service can use Serviced Component class as the base class. Table 2 summarizes these service elements. In this study, itis called RDA-Service.

(Table 2) Main RDA-Service elements

4. RDA-.NET Profile

We propose a UML profile that supports RDA-Servicespecifications based on the meta-model defined above and a UML profile for .NET/C#. This profile assumes a. NET/C#-related UML profile and adds the RDA-Service elements defined in this study. In this study, it is called RDA-.NET profile.

4.1 RDA-Service Specification Elements

In Table 3, transaction support expresses the generated code as having a transaction attribute as a component. A class or component specified as a «Transaction» stere otype will have the transaction attribute to be supported when participating in the transaction as needed. The transactiontermination is specified by the «AutoComplete» method, and therefore, the generated code automatically determines whether to commit or cancel the entire transaction including the component depending on whether the error occurred at the end of the method. It is the role that can be performed.

Security uses the {Security = “role name”, Set Every one Access = value} tagged value, and the role name specifies the policyname (role name) that sets security-related policies and roles. The SetEveryoneAccess property is a setting for control permissions for all user groups. If the property is set to true, all user groups are automatically added to the role. Object pooling refers to a mechanism that activates an object in apool rather than creating a new one when the client requests the component by pooling an instance of the required component in advance.

Just-In-Time (JIT) activation refers to deactivating anobject immediately when the component completes its work, even if the client maintains a reference to the component. When the client invokes the second method in this component, it instantaneously activates an instance of a new component. In other words, when Just-In-Time activation is used, the components used by the client are different each time the method is invoked. Timely activation helps ensuretransaction accuracy, especially consistency and isolation.

(Table 3) UML profile element for RDA-servicespecification

4.2 Element for .NET/C# Specifications of RDA-.NET Profile

We propose a meta-model that defines the essentialelements, syntax, and structure of each PSM element for. NET. The PSM meta-model defines the PSM model and adesign model element to be transformed when the PSM model is generated. The PSM meta-model defines PSM meta-model elements, types, and meta-classes for each PSM model element and describes the constraints. The PSM meta-model classifies the items to be expressed in PSM byclassifying them as shown in Table 4. Elements common to all layers, such as “C# Operator,” are described in the common layer.

Table 5 defines the components of the UML profile for the .NET / C # specification in the RDA-.NET profile. Theseprofile elements are intended to extend the PSM meta-modelelements for .NET to generate PSM models for .NET / C #.

4.3 Component development process applying RDA-.NET profile

We developed a prototype tool based on StarUML tomake the proposed technique more practical and easy to use. Star UML can objectize modules to access most programs such as UML meta-model and application object, expose the API to the outside, and easily develop plug-ins. In thischapter, we propose the component development processapplying the RDA-.NET Profile and StarUML plug-ins, as shown in Figure 3. In the requirements analysis phase, therequirements specification is analyzed to derive functional and nonfunctional requirements.

First, the RDA-.NET Profile is created in the XML/XMI format as defined above, and it is developed using Star UML plug-ins for use. In the next PIM design phase, the service element based on a real-time distributed architecture is designed using plug-ins. In this paper, platform independent design using RDA-.NET Profile is defined as &ld quo;RDA-PIM. &rd quo;In the PSM design stage, the rough RDA-PIM design is used to create a detailed PSM design for .NET that considers the. NET platform using the specification elements provided by the profile. Finally, in the code generation step, the PSM is generated using RDA-.NET Profile plug-ins, and the .NET component artifact including the .Net attribute code is generated. This study focuses on the scope of PIM and PSM design except code generation.

(Table 4) PSM meta-model element for .NET

(Table 5) UML profile element for .NET/C# specification

(Figure 3) Component development process applying the RDA-.NET profile

5. Case Study

We applied the rental/reservation management function to Best Car Corporation’s (BCC) sales (car rental) managementsystem. It is based on StarUML, .NET/C #, and XML/XMI.

5.1 RDA-PIM design

After doing necessary work such as creating the icon fileand registry registration file corresponding to the RDA-.NET profile defined above, a profile is added to the new project through StarUML’s profile manager. After including the RDA-.NET profile, we designed the PIM for the system to be developed. At this time, the RDA-Service specificationdefined above is generated in the required class, component, or method by using the developed plug-ins.

Figure 4 shows the stereotype of the RDA-.NET profileand the content of the tag definition item by using the extension attribute editor of the plug-ins. The set values areautomatically generated in the form of stereotype, tagged value, OCL, etc.

(Figure 4) Setting values of elements defined in RDA-.NET profile

(Figure 5) Example of generated RDA-PIM

Figure 5 shows that the “Rental” class supports transactionattributes and the “checkOut” method is created to support the & ld quo;AutoComplete&rd quo; attribute for transaction termination and &ld quo; Just In Time Activation.” In the “CarItem” class, property values for object pooling are generated in the OCL format.

5.2 Generation of PSM for .NET

After generating the RDA-PIM, we generate the PSM for. NET using the items from the .NET/C# specification of RDA-.NET Profile. For this purpose, we define the transformation rules and constraints necessary for transforming PIM to PSM. The QVT for transformation between the MOF-based models established by OMG consists of thelanguage for model generation, language for model query, and transformation definition language for describing transformation rule [11]. Figure 6 shows the definitions used when mapping a PIM model to a PSM for .NET based on QVT. The RDA-Service element defined in the RDA-.NET Profile is a. NET attribute class, and the .NET/C# element is PSM for .NET and is converted into model definition items. Source/target conditions are written using OCL Boolean expressions.

Figure 7 shows the result of modeling RDA-PIM and generating PSM for .NET through the add-in that implements the transformation rule. The example in Figure 7 shows that the RDA-Service element defined in the RDA-.NET profileand the PSM meta-model definition elements for .NET aregenerated as a class diagram for the rental/reservation management module of BCC’s sales management system.

(Figure 6) Realization of transformation rule using transformation definition language

(Figure 7) Rental/reservation administration class diagram (PSM)

6. Conclusions

In this study, we propose an RDA-.NET profile for RDA-based services such as transaction, security, synchronization service, and object pooling that are essential for enterprise applications as well as extension models for. NET platform. In addition, it was constructed to apply it to the StarUML open source modeling platform; plug-ins that was implemented and applied the defined meta-model, transformation rule, etc.; and generated RDA-PIM and PSM for .NET.

The RDA-.NET profile is an XMI-based XML document that can be added or modified easily, and the plug-ins can be applied easily using an external API. In addition, the RDA-.NET profile supports OMG’s UML Profile function and conforms to MOF, and therefore, it can be used with MOF-compliant UML tools and MDA tools. Therefore, we can use the proposed method to easily and quickly generatere usable extension models even if we do not know low-levelinformation about the functions to be considered in the .NET platform and RDA, and it can increase the productivity, scalability, portability, and maintainability of the designmodel.