The growing complexity and heterogeneity of modern IT systems demand for intelligent management tools, capable of horizontally integrating technologies of different vendors and domains and vertically relating them with business processes and high level requirements. Due to their often hard-coded and unextendable management models, existing tools are not able to meet those requirements well. Recent advances in semantic web technologies let ontologies experience a revival for the modeling of domain knowledge and new standards as the Web Ontology Language (OWL) have been established by the W3C. The abilities to semantically model, map and link independent domains let them appear as very suitable for the application in IT management. Nevertheless, approaches for the implementation of an ontology-based IT management have shown that the scalability for large domain models is insufficient, important aspects are not expressible using the standards and the integration of continuous monitoring data is difficult. In this paper, dedicated solutions for each of those problems will be presented and combined into a comprehensive, ontology-based management framework. The proposed approach has been experimentally validated in a case study of a medium-sized management problem for an air traffic management system.

In this paper, an approach for runtime analysis and automated knowledge-based IT management is presented and applied to the example of an Air Traffic Control (ATC) system. An analysis method has been developed, which combines the strengths of formal ontologies and Complex Event Processing (CEP). Thereby, the configuration of the whole analysis process is derived from one homogeneous knowledge source, a formal ontology model, which contains the system topology, the events that occur in the system, aggregations and Service Level Agreements (SLAs). Ontology rules are evaluated using semantic reasoning, event aggregations are translated into rules for the CEP engine. During runtime, data from the Managed System is classified to be either low-frequent or high-frequent and is accordingly either mapped to the ontology or used as input for the CEP engine. The aggregated information from both processes is used as input for the planning of reconfigurations on the Managed System.

Today, an increasing number of enterprise applications are based on Service Oriented Architectures (SOA). The complexity of these applications requires Service Level Management (SLM) from the business process layer down to the actual implementation of application components. However, this complexity also hinders continuous application management, which relies on monitoring non-functional properties such as performance. A major challenge is to create a unified view on the overall system including (implementation level) performance across newly developed services and legacy components. In this paper, we present a comprehensive performance-aware application design method that can be applied to newly developed applications and legacy applications. The presented method is a result of the IT management project PerManEntA.

In this paper, we present a design for a generic, open, application-oriented performance instrumentation of multi-tier applications. Measurements are performed through configurable instrumentation points at the middleware level and can be combined with application-level measurements for a conjoined analysis. In addition, we present a prototypical realisation of the design for two commonly used middleware components: Apache Tomcat and J Boss. Our approach may be used in a wide variety of application scenarios like providing a monitoring architecture for SLM scenarios or as a performance-debugging platform during application development. The architecture uses open standards and APIs and may therefore be seamlessly integrated into existing management environments.

Along with the increasing diversity of educational markup languages there is a strong need for flexible integration ofsuch content into learning platforms. Therefore, we have identified four basic mechanisms: plain linking from the platform to external content, conversion of content into the platforms native format, and service-based invocation of external content as well as specific functionality related to it. Architectural principles, benefits, and drawbacks of these concepts are compared, and exemplary realizations are described.

Service level management (SLM) has gained more and more importance in the past few years. One of the biggest challenges is the integration of emerging new technologies such as Web services. A large number of different SLM approaches has been proposed which complicates an efficient SLM. This paper describes an SLM approach that is based on the model driven architecture (MDA). The first step is to specify abstract reusable SLA patterns which are bound later to a concrete management platform and are finally physically deployed into the managed environment. This approach benefits from the advantages of the MDA and provides a mechanism for transforming SLA patterns for different SLA management platforms. Our approach has been prototypically implemented for the Web services level agreement (WSLA) environment.

This paper contributes to service level management of complex Web-based e-business environments using WBEM/CIM. Such e-business environments usually consist of Web servers and Web containers to realize client access, and EJB containers or CORBA components for modeling the application business logic. Since the DMTF does not define a model providing a unified view upon such complex environments, the definition of a management information model is the core part of the work presented. Currently, the information model mainly focuses on performance aspects, like application response times, which are integral part of many SLAs. The paper also presents a framework that was developed to efficiently implement the information model. The framework increases the portability of CIM providers, which are responsible for retrieving management information, between different CIMOMs by providing an abstraction layer. In addition, the framework simplifies the development of providers by offering support for caching etc.

The Common Object Request Broker Architecture (CORBA) is often used as backbone middleware for connecting critical business system components and for integrating legacy systems. Therefore, CORBA applications have to be managed in an efficient manner. The emerging trend of service level agreements and service level management requires the management of a system from an end-user's viewpoint, i.e., metrics like application response time and availability are key concerns. This requires a very fine-grained monitoring of the application in order to identify its performance-critical parts. This paper presents a new generic instrumentation approach for CORBA applications that enables the measurement of end-to-end performance characteristics. The measurements are very fine-grained, i.e., complex invocation hierarchies within object meshes can be monitored. The presented solution is based on portable interceptors and the application response measurement (ARM).

Enterprise Java Bean (EJB) application servers are gaining more and more importance for implementing business-critical applications. For an effective service-level management (SLM), an instrumentation must offer a fine-grained picture of the real system performance. For reasons of efficiency and practicability, the instrumentation has to be performed automatically in order to assure complete and comparable measurements. This paper presents a new approach for an automatic and generic performance instrumentation of EJB applications by instrumenting the EJB server. The approach defines a generic CIM model for EJB applications. From an application developer's point of view, the instrumentation is completely transparent. It is realised using the Java Management Extensions (JMX). The performance measurements are implemented using Application Response Measurement (ARM). The prototype is integrated into a WBEM/CIM object manager.

During the past years, enterprises became more and more dependent on the business processes that are often implemented using CORBA middleware. Todays management platforms ignore the dependency between applications and their middleware, and thus give up valuable information sources that are required for proactive management. In this paper an Integration System is presented by which traditional management platforms are widened for managing CORBA applications. Thus, the investments for an existing management platform are protected. The Integration System consist of a flexible and highly available Integration Agent and the Generic Management Interface for querying management-relevant information from CORBA applications.

The distributed measurement system JEWEL, developed within project RelaX, is described. JEWEL consists of a flexible toolkit for low-interference online performance measurement integrated with a powerful adaptable graphical presentation facility and a generic interactive experiment control system. JEWEL supports a large set of different system models as well as a wide variety of interfaces to the observed system. Two examples are presented in order to demonstrate its flexibility.>

The authors provide a description of RelaX (reliable distributed applications support on UniX), a portable and extensible system software layer on top of UNIX-like operating system kernels that supports reliable distributed applications by a generalized transaction mechanism. The transaction mechanism relieves each programmer of dealing explicitly with error recovery and concurrency control in every distributed application. In order to make transactions applicable as a general programming tool, flexibility has been introduced into the traditional transaction concept. The transaction mechanism is isolated in a server (Transaction Manager) that cooperates with an extensible set of resource managers, which provide different kinds of long-term storage entities accessible by RelaX transactions. Each resource manager provides a standard interface to the transaction kernel, and, if so desired, additional resource managers can be built. In order to ease the construction of new resource managers, RelaX provides generic software components as building blocks for any kind of resource manager. The RelaX architecture is described and the design of an examplary resource manager, the transactional object management system which provides access to persistent shared objects, is outlined.>

Transactions are especially valuable in distributed systems, since they isolate the programmer from the effects of both concurrency and failures. In implementing transactions at the system level, flexibility has to be introduced into the transaction concept. Specifically, the premature release of data objects has to be addressed. To assure recoverability, resulting dependencies between transactions are stored by the system in a distributed data structure called a recovery graph. The storing of redundant information in the recovery graphs at the different sites reduces the complexity of the commit protocol, and a chase protocol used to abort transactions can be derived which excludes infinite chasing. The redundant information can be distributed almost for free because it can be piggybacked on messages. The new commit/abort protocols will be used in the RelaX project (reliable distributed applications support on Unix), which carries on work done at GMD in the PROFEMO project on distributed transaction mechanisms.>

Type-specific locking is designed to increase performance of distributed transactions by allowing competing transactions to concurrently alter shared objects concurrently, provided their changes are commutative. When one of the set of compatible transactions commits or aborts, a problem arises due to the indeterminacy of the alterations of the others. A tree of nineteen solutions to the problem has been investigated. Given the necessary support by the underlying architecture, this tree can be pruned severely. The problem and set of approaches came to the authors' attention during design for type-specific locking in PROFEMO, an operating system for a local area network that provides a location-independent object environment and built-in mechanisms for transaction control and recovery. A description is given of the problem, the possible solutions, and the arguments that allow the pruning. Testbed results are not yet available, since type-specific locking has not yet been implemented at the time of the initial tests of the PROFEMO system.>