In order to manage a service to meet the agreed upon SLA, it is important to design a service of the required capacity and to monitor the service thereafter for violations at runtime. This objective can be achieved by translating SLOs specified in the SLA into lower-level policies that can then be used for design and enforcement purposes. Such design and operational policies are often constraints on thresholds of lower level metrics. In this paper, we propose a systematic and practical approach that combines fine-grained performance modeling with regression analysis to translate service level objectives into design and operational policies for multi-tier applications. We demonstrate that our approach can handle both request-based and session-based workloads and deal with workload changes in terms of both request volume and transaction mix. We validate our approach using both the RUBiS e-commerce benchmark and a trace-driven simulation of a business-critical enterprise application. These results show the effectiveness of our approach.

Capturing and reusing the experience of operators in implementing IT changes is an important aspect of IT service management, as it may result in fewer incidents (upon change execution) and faster specification of change plans, to mention just a few potential advantages. Nevertheless, in practice, changes are usually described and documented in an ad hoc fashion, due to the lack of proper support to assist the design process. This hampers knowledge acquired when specifying, planning, and carrying out previous changes to be reused in subsequent requests. In order to address this issue, we propose the use of change templates as a mechanism to formalize, preserve, and reuse the experience accumulated within organizations in relation to IT changes. Our solution is analyzed through a prototypical implementation of a change management system and a case study based on a real-life scenario.

Large complex systems (such as Enterprise systems) are often composed of several interacting, independent components. In many such systems, although the behavior of the constituent components is well characterized, the behavior that results from interaction between such components is more or less intractable; making it hard for the administrators to efficiently manage the system in conformance with the service level agreements or the SLAs. This paper presents an approach for deriving component-level objectives from system-level objectives or agreements, which if conformed to, imply conformance to the higher-level SLA. Our approach partitions the systempsilas state-space into homogeneous sub-spaces, creates micro-models for such subspaces, and then uses such micro-models to translate the higher-level objectives to component-level objectives. We have implemented a system, termed Pranaali, for evaluating our approach in realistic settings.

The current research on IT change management has been exploring several aspects of this new discipline, but it usually assumes that changes expressed in requests for change (RFC) documents will be successfully executed over the managed IT infrastructure. This assumption, however, is not realistic in actual IT systems because failures during the execution of changes do happen and cannot be ignored. In order to address this issue, we propose a solution where tightly-related change activities are grouped together forming atomic groups of activities. These groups are atomic in the sense that if one activity fails, all other already executed activities of the same group must rollback to move the system backwards to the previous state. The automation of change rollback is especially convenient because it relieves the IT human operator of manually undoing the activities of a change group that has failed. To prove concept and technical feasibility, we have materialized our solution in a prototype system that, using elements of the business process execution language (BPEL), is able to control how atomic groups of activities must be handled in IT change management systems.

The current approach for modeling synchronization in business processes relies on sequencing constructs, such as sequence, parallel etc. However, sequencing constructs obfuscate the true source of dependencies in a business process. Moreover, because of the nested structure and scattered code that results from using sequencing constructs, it is hard to add or delete additional constraints without over-specifying necessary constraints or invalidating existing ones. We propose a dataflow programming approach in which dependencies are explicitly modeled to guide activity scheduling. We first give a systematic categorization of dependencies: data, control, service and cooperation. Each dimension models dependency from its own point of view. Then we show that dependencies of various kinds can be first merged and then optimized to generate a minimal dependency set, which guarantees high concurrency and minimal maintenance cost for process execution.

Shared services, hosted in utility computing environments are becoming quite common in enterprises. These services could be clusters of application servers hosting various applications or even clusters of databases catering to multiple organizations within an enterprise. Automating the provisioning of these shared services is a difficult problem. We propose a model-based automation mechanism to provision such shared services. We demonstrate our model-based provisioning system in the case of a shared desktop service. The shared desktop service termed the "virtual desktop system" (VDS) hosts desktops on top of virtual machines. These desktop virtual machines are provisioned on consolidated data centers while users use thin clients to connect to their "virtual" desktops. We demonstrate how we use our model-based automation technique to simplify the provisioning of such desktops.

Systems are typically designed based on certain high level goals, such as performance and availability. On the other hand, during operation, usually only low level metrics (e.g., CPU utilization) are measured. The system administrators use their expertise to implicitly map bounds on these metrics such that the high level goals are met. The objective of this research is to create an automated and domain independent approach to derive policy bounds on the low level metrics such that the high level goals are met. These policies may be also be used for monitoring the system for goal assessment purposes. The refinement is carried out using a combination of data classification and test-and-development approaches. An ad hoc system is deployed and a dataset containing values of selected metrics is collected by placing appropriate workloads on the system. The policy bounds are derived by applying classification techniques on this dataset. The classification rules are further refined using statistical distributions to arrive at certain low level rules that are useful for system monitoring and to check the system health when it is deployed and running. We show the validity of our approach for an e-commerce auctioning system (RubiS).

Utility computing environments provide on-demand IT services to customers. Such environments are dynamic in nature and continuously adapt to changes in requirements and system state. Errors are an important category of environment state changes as such environments consist of a large number of components, and hence, are subject to errors. In this paper, we design and implement a model-based simulation framework that leverages information about existing service components and their interactions, and provides concrete service behavior in presence of a variety of errors. To evaluate the framework, experiments are conducted on a virtualized blade-server based environment. Results show that the framework is effective and practical in analyzing error impacts on IT services.

BPEL is emerging as an open-standards language for Web service composition. However, its procedural style can lead to inflexible and tangled code for managing a crosscutting aspect - synchronization constraints that define permissible sequences of execution for activities in a process. In this paper, we present DSCWeaver, a tool that enables a synchronization-aspect extension to BPEL. It uses DSCL, a synchronization expression language, to specify constraints. DSCL has the desirable features of declarative syntax, fine granularity, and validation support. A designer can use DSCL to describe and validate the synchronization behavior and rely on DSCWeaver to generate BPEL code. We demonstrate the advantages of our approach in a service deployment process and evaluate its performance using two metrics: lines of code (LoC) and places to visit (PtV). Evaluation results show that our approach can effectively reduce development effort of process designers while providing performance competitive to un-woven BPEL code

In this work, the performance of various machine learning classifiers with regard to bottleneck detection in enterprise, multi-tier applications governed by service level objectives is described. Specifically, in this paper, it demonstrates the effectiveness of three classifiers, a tree-augmented Naive Bayesian network, a J48 decision tree, and LogitBoost, using our bottleneck detection process, which delves into a new area of performance analysis based on the trends of metrics (first order derivative) rather than the metric value itself. Furthermore, the efficiency of each classifier by measuring the convergence speed, or the number of staging trials required in order to provide positive results is illustrated. Finally, the effectiveness of the classifiers used in the bottleneck detection process as each classifier strongly identifies the enterprise system bottleneck

The increasing complexity of enterprise and distributed systems demands automated design, testing, deployment, and monitoring of applications. Testing, or staging, in particular poses unique challenges. In this paper, we present the Elba project and Mulini generator. The goal of Elba is creating automated staging and testing of complex enterprise systems before deployment to production. Automating the staging process lowers the cost of testing applications. Feedback from staging, especially when coupled with appropriate resource costs, can be used to ensure correct functionality and provisioning for the application. The Elba project extracts test parameters from production specifications (such as SLAs) and deployment specifications, and via the Mulini generator, creates staging plans for the application. We then demonstrate Mulini on an example application, TPC-W, and show how information from automated staging and monitoring allows us to refine application deployments easily based on performance and cost.

One of the challenges grid technology faces today is the adoption in other domains than scientific computing, where it originated. However, in order to be usable and useful into other domains, it needs to be adapted and extended to fit the needs of the domain and yet maintains the standards defined by OGSA (I. Forster et al., 20020) and WSRF (2004). We focus on the domain of enterprise grids (S. Robinson, 2004), which are comprised of the interconnected data centers as they exist in commercial enterprises forming large pools of geographically distributed IT resources that are shared among numerous IT applications. In this paper, we compare the commonalities and differences between compute grids (I. Foster and C. Kesselman) and enterprise grids. We then introduce the concept of resource topologies which is important for enterprise grids. A design tool is presented for designing resource topologies. In the second part of the paper we introduce the problem of resource composition and present a solution for exploring a space of possible resource compositions for meeting application requirements using a policy-based constraint satisfaction method.

Utility computing is envisioned as the future of enterprise IT environments. Achieving utility computing is a daunting task, because enterprise users have diverse and complex needs. In this paper we describe quartermaster, an integrated set of tools that addresses some of these needs. Quartermaster supports the entire lifecycle of computing tasks - including design, deployment, operation, and decommissioning of each task. Although individual components of this lifecycle have been addressed in earlier work, quartermaster integrates them in a unified framework using model-based automation. All tools within quartermaster are integrated using models based on the common information model (CIM), an industry-standard model from the distributed management task force (DMTF). The paper discusses the quartermaster implementation, and describes two case studies using quartermaster.

Distributed applications typically interact with a number of heterogeneous and autonomous components that evolve independently. Methodical development of such applications can benefit from approaches based on domain-specific languages (DSLs). However, the evolution and customization of heterogeneous components introduces significant challenges to accommodating the syntax and semantics of a DSL in addition to the heterogeneous platforms on which they must run. In this paper, we address the challenge of implementing code generators for two such DSLs that are flexible (resilient to changes in generators or input formats), extensible (able to support multiple output targets and multiple input variants), and modular (generated code can be re-written). Our approach, Clearwater, leverages XML and XSLT standards: XML supports extensibility and mutability for in-progress specification formats, and XSLT provides flexibility and extensibility for multiple target languages. Modularity arises from using XML meta-tags in the code generator itself, which supports controlled addition, subtraction, or replacement to the generated code via XML-weaving. We discuss the use of our approach and show its advantages in two non-trivial code generators: the Infopipe Stub Generator (ISG) to support distributed flow applications, and the Automated Composable Code Translator to support automated distributed application deployment. As an example, the ISG accepts as input an XML description and generates output for C, C++, or Java using a number of communications platforms such as sockets and publish-subscribe.

A utility environment is dynamic in nature. It has to deal with a large number of resources of varied types, as well as multiple combinations of those resources. By embedding operator and user level policies in resource models, specifications of composite resources may be automatically generated to meet these multiple and varied requirements. The paper describes a model for automated policy-based construction of complex environments. We pose the policy problem as a goal satisfaction problem that can be addressed using a constraint satisfaction formulation. We show how a variety of construction policies can be accommodated by the resource models during resource composition. We are implementing this model in a prototype that uses CIM as the underlying resource model and exploring issues that arise as a result of that implementation.

Grid computing has relied on "best effort" as the guiding principal of operation. However, commercial grids need to provide much stricter guarantees. These guarantees have to be specified in terms of service level agreements and have to be monitored and assured. We propose an architecture for specifying and monitoring service level agreements to achieve the above. The architecture relies on a network of communicating proxies each maintaining SLAB committed within the administrative domain of the proxy. SLAB are either negotiated between or specified to management proxies, and they are responsible for automated monitoring of data and for triggering evaluations of the registered SLAs. An unambiguous and,flexible language for formalizing SLAB is presented to achieve the above. The management proxy allows reasoning about the overall status of SLAB related to an application context across multiple administrative domains by contacting and querying involved management proxies, obtaining measurement information from multiple proxies, if needed and performing a consolidated SLA evaluation. The process of measurement collection, and SLA evaluation is automated and based on web services technology. The scenario considers HP Utility Data Center as a typical Commercial Grid deployment environment.

As Web services become more prevalent, the nature of electronic transactions on the Internet changes from simple browser-to-business clicks to an orchestrated flow of messages between cross-enterprise services. Consequently, more than one service could participate in the federated execution of a single transaction. In such cases, the problem of end-to-end management becomes very important. The inherent cross-enterprise or distributed nature of the problem, security of information exchanged, and the complexity in correlating related messages into a single transaction make this problem challenging. We present an approach to track and correlate messages between Web services that are part of a single transaction. We do this by proposing management information exchange agreements between service providers, and a distributed message tracking algorithm that is executed within each service provider. We also explain the techniques for realizing our solution in the case of Web services that communicate using the Simple Object Access Protocol (SOAP).

In this paper we describe a distributed and dynamic architecture for network management of a heterogeneous distributed system which we have implemented in order to perform network management of our local distributed system. The architecture is highly generic in nature and can be extended to a large heterogeneous network. The architecture is distributed in nature as it provides for multiple managers acting simultaneously. It is rendered dynamic by the utilization of mobile agents for the implementation of network management functionalities. The network managers in our architecture utilize client-server technology and/or mobile agent technology as and when required depending on the functionality implemented and their location. In this context we have implemented a Mobile Network Manager (MNM) which is a location independent network manager. Mobile agents are furnished by MAGENTA (Mobile AGENT environment for distributed Applications) which we have implemented for this purpose.