The migration of software systems to IaaS (infrastructure as a service)- or PaaS (platform as a service)-based cloud environments enables SaaS providers to benefit from the cloud’s merits, such as smoothly scaling up and down existing applications. Our approach, CloudMIG, aims at supporting SaaS providers to perform those migrations. Here, validating the specific constraints that are imposed by a cloud environment constitutes an important early-phase activity. For example, the access to the file system, number of files, or calls to specific methods may be restricted by cloud providers. Those constraints have to be considered when evaluating the suitability of competing cloud environment candidates. In this paper, we describe CloudMIG’s corresponding parts: a generic cloud environment model that incorporates these constraints and appropriate violation detection mechanisms. A software system’s conformance can be examined with the assistance of constraint validators. They operate on extracted Knowledge Discovery Meta-Model-based system models and can, among others, apply metrics formulated with the Software Metrics Meta-Model through our metrics execution engine. Additional constraint validators can be plugged into the validation process as needed. In this context, we implemented a prototype and modeled the PaaS environment Google App Engine for Java. We report on a quantitative evaluation regarding the detected constraint violations of five open-source systems.

Automatic Conformance Checking for Migrating Software Systems to Cloud Infrastructures and Platforms

C++ Exceptions provide a useful way for dealing with abnormal program behavior, but often lead to irregular interprocedural control flow that complicates compiler optimizations and static analysis. In this paper, we present an interprocedural exception analysis and transformation framework for C++ that captures the control-flow induced by exceptions and transforms it into an exception-free program that is amenable for precise static analysis. Control-flow induced by exceptions is captured in a modular interprocedural exception control-flow graph (IECFG). The IECFG is further refined using a novel interprocedural dataflow analysis algorithm based on a compact representation for a set of types called the Signed-TypeSet domain. The results of the interprocedural analysis are used by a lowering transformation to generate an exception-free C++ program. The lowering transformations do not affect the precision and accuracy of any subsequent program analysis. Our framework handles all the features of synchronous C++ exception handling and all exception sub-typing rules from the C++0x standard. We demonstrate two applications of our framework: (a) automatic inference of exception specifications for C++ functions for documentation, and (b) checking the "no-throw" and "no-leak" exception-safety properties.

Interprocedural exception analysis for C

Modeling languages such as SysML provide various description means for a precise specification of the desired system. As a system model typically uses multiple diagram types focusing on different aspects, it is crucial to keep them consistent to each other. In this paper, we propose a verification methodology which ensures the consistency between activity diagrams as blueprints for the implementation and their contracts from a block definition diagram. For this purpose, activity diagrams are transformed to OCL constraints that can be checked against pre- and postconditions. The proposed approach is evaluated in a case study based on an industrial specification.

/pdf/verifying-consistency-between-activity-diagrams-and-their-35e49kx9iv.pdf

Verifying consistency between activity diagrams and their corresponding OCL contracts

Many SaaS providers nowadays want to leverage the cloud's capabilities also for their existing applications, for example, to enable sound scalability and cost-effectiveness. This thesis provides the approach CloudMIG that supports SaaS providers to migrate those applications to IaaS and PaaS-based cloud environments. CloudMIG consists of a step-by-step process and focuses on two core components. (1) Restrictions imposed by specific cloud environments (so-called cloud environment constraints (CECs)), such as a limited file system access or forbidden method calls, can be validated by an automatic conformance checking approach. (2) A cloud deployment option (CDO) determines which cloud environment, cloud resource types, deployment architecture, and runtime reconfiguration rules for exploiting a cloud's elasticity should be used. The implied performance and costs can differ in orders of magnitude. CDOs can be automatically optimized with the help of our simulation-based genetic algorithm CDOXplorer. Extensive lab experiments and an experiment in an industrial context show CloudMIG's applicability and the excellent performance of its two core components.

https://pi.informatik.uni-siegen.de/stt/34_3/05_Dissertationen/stt_frey.pdf

Conformance Checking and Simulation-based Evolutionary Optimization for Deployment and Reconfiguration of Software in the Cloud

Testing application behavior in the presence of I/O failures is extremely difficult. The resources used for testing usually work without failure. Failures typically cannot be initiated on the test suite level and are usually not tested sufficiently. Essentially, each interaction of the application with the environment can result in a failure. The Enforcer tool identifies such potential failures and automatically tests all relevant outcomes of such actions. It combines the structure of unit tests with coverage information and fault injection. By taking advantage of a unit test infrastructure, performance can be improved by orders of magnitude compared to previous approaches. This paper introduces the usage of the Enforcer tool.

/pdf/exhaustive-testing-of-exception-handlers-with-enforcer-2p7aaiw0wu.pdf

Exhaustive testing of exception handlers with enforcer

Many programming languages provide exceptions as a structured way for detecting and recovering from abnormal conditions. However, using exceptions properly is non-trivial. Programmers are often careless when handling exceptions, and exception related mistakes are common in software products. We present a technique for verifying that exceptions are used in a safe way. This technique integrates static analysis with model checking to visit all possible exception-raising execution paths. To demonstrate the potential utility of our approach, we applied it to two open source Java applications.

Towards automatic exception safety verification

Software components, services, or modules are used via their application programming interface (API) For any sufficiently complex component, there are strict rules on the order and context in which particular methods of the API can be invoked For example, a file must be opened before reading, and not read after closing These constraints are called API conformance rules Their violation at run-time creates errors, which are often subtle and difficult to diagnose In general, API conformance rules cannot be statically checked if concurrency is involved We present a verification framework, called Fex, that assists in Java API conformance verification Fex operates as follows The first step is to express the API conformance rules as executable specifications Then, the program under investigation is instrumented such that all potential exceptions can be easily raised Next, the program is sliced to retain only control flow and the relevant APIs The executable API conformance rules and sliced program are then processed by the Java Path Finder model checker Possible violations of the conformance rules are exhibited as exceptions during model checking We have successfully applied our framework to the TSAFE reference air traffic control system and identified a subtle deadlock missed by previous verification efforts

Xin Li

Papers

Towards automatic exception safety verification

API conformance verification for Java programs