Blockchains have become increasingly important in recent years and have expanded their applicability to many domains beyond finance and cryptocurrencies. This adoption has particularly increased with the introduction of smart contracts, which are immutable, user-defined programs directly deployed on blockchain networks. However, many scenarios require business transactions to simultaneously access smart contracts on multiple, possibly heterogeneous blockchain networks while ensuring the atomicity and isolation of these transactions, which is not natively supported by current blockchain systems. Therefore, in this work, we introduce the Transactional Cross-Chain Smart Contract Invocation (TCCSCI) approach, which supports such distributed business transactions while ensuring their global atomicity and serializability. The approach introduces the concept of Resource Manager Smart Contracts (RMSCs), and 2PC for Blockchains (2PC4BC), a client-driven Atomic Commit Protocol (ACP) specialized for blockchain-based distributed transactions. We validate our approach using a prototypical implementation, evaluate its introduced overhead, and prove its correctness.

The Infrastructure as Code (IaC) concept enables IT infrastructure to be managed as software: resources can be managed, monitored, and provisioned automatically instead of manually by developers or operations teams. Many industries have already embraced this concept widely. However, research on IaC-based deployments, particularly research focusing on loose coupling, often does not offer methods for evaluating architectural conformance, spotting architecture smells, and support for correcting the found smells. Our work strives to provide an automatic method for continuously developing microservice-based systems and the associated infrastructure. We aim to offer an automated architectural refactoring method that checks if IaCbased deployments adhere to patterns and best practices and do not contain potential architectural smells. We provide architects with viable options for enhancing architectural conformance during microservice development. In short, by continuously detecting architectural smells and suggesting possible fixes, we aim to support architecture evolution within the framework of continuous delivery practices. We evaluate our approach using three case studies and variants based on open-source microservice architectures.

Abstract Modern component-based architectural styles, e.g., microservices, enable developing the components independently from each other. However, this independence can result in problems when it comes to managing issues, such as bugs, as developer teams can freely choose their technology stacks, such as issue management systems (IMSs), e.g., Jira, GitHub, or Redmine. In the case of a microservice architecture, if an issue of a downstream microservice depends on an issue of an upstream microservice, this must be both identified and communicated, and the downstream service’s issues should link to its causing issue. However, agile project management today requires efficient communication, which is why more and more teams are communicating through comments in the issues themselves. Unfortunately, IMSs are not integrated with each other, thus, semantically linking these issues is not supported, and identifying such issue dependencies from different IMSs is time-consuming and requires manual searching in multiple IMS technologies. This results in many context switches and prevents developers from being focused and getting things done. Therefore, in this paper, we present a concept for seamlessly integrating different IMS technologies into each other and providing a better architectural context. The concept is based on augmenting the websites of issue management systems through a browser extension. We validate the approach with a prototypical implementation for the Chrome browser. For evaluation, we conducted expert interviews, which approved that the presented approach provides significant advantages for managing issues of agile microservice architectures.

Abstract Function‐as‐a‐Service (FaaS) is a cloud service model enabling to implement serverless applications for a variety of use cases. These range from scheduled calls of single functions to complex function orchestrations executed using orchestration services such as AWS step functions. However, since the available function orchestration technologies vary in functionalities, supported modeling languages, and APIs, modeling such function orchestrations and their deployment require significant technology‐specific expertise. Moreover, the resulting models are typically not portable due to provider‐ and technology‐specific details, and major efforts are required when exchanging an orchestrator or provider due to such lock‐ins. To tackle this issue, we introduce a vendor‐ and technology‐agnostic method for the modeling and deployment of serverless function orchestrations, which relies on the business process model and notation (BPMN) and topology and orchestration specification for cloud applications (TOSCA) standards for modeling function orchestrations and their deployment, respectively. We also present a toolchain for modeling serverless function orchestrations in BPMN, generating proprietary models supported by different function orchestration technologies from BPMN models, specifying their actual deployment in TOSCA, and then enacting such deployment. Finally, we illustrate a case study applying our method and toolchain in practice.

Various deployment technologies have been released to support automating the deployment of distributed applications. Although many of these technologies provide general-purpose functionalities to deploy applications as well as infrastructure components, different technologies provide specific capabilities making them suited for different environments and application types. As a result, the deployment of complex distributed applications often requires to combine several deployment technologies expressed by different deployment models. Thus, multiple deployment models are processed by different technologies and must be either orchestrated manually or the automated orchestration must be developed individually. To address these challenges, we present an approach (i) to annotate parts of a holistic deployment model that should be deployed with different deployment technologies, (ii) to automatically transform an annotated model to multiple technology-specific models for different technolo gies, and (iii) to automatically coordinate the deployment execution with different technologies by employing a centralized orchestrator component. To prove the practical feasibility of the approach, we describe a case study based on a third-party application.

The diversity of available cloud service models yields multiple hosting variants for application components. Moreover, the overall trend of reducing control over the infrastructure and scaling configuration makes it non-trivial to decide which hosting variant suits more a certain software component. In this work, we introduce a spectrum of component hosting patterns that covers various combinations of management responsibilities related to (i) the deployment stack required by a given component as well as (ii) required infrastructure resources and component’s scaling rules. We validate the presented patterns by identifying and showing at least three real world occurrences of each pattern following the well-known Rule of Three.

Function-as-a-Service (FaaS) is a cloud service model enabling developers to offload event-driven executable snippets of code. The execution and management of such functions becomes a FaaS provider’s responsibility, therein included their on-demand provisioning and automatic scaling. Key enablers for this cloud service model are FaaS platforms, e.g., AWS Lambda, Microsoft Azure Functions, or OpenFaaS. At the same time, the choice of the most appropriate FaaS platform for deploying and running a serverless application is not trivial, as various organizational and technical aspects have to be taken into account. In this work, we present (i) a FaaS platform classification framework derived using a multivocal review and (ii) a technology review of the ten most prominent FaaS platforms, based on the proposed classification framework. We also present a FaaS platform selection support system, called FaaStener, which can help researchers and practitioners to choose the FaaS platform most suited for their requirements.

\n The adoption of cloud computing combined with DevOps enables\n companies to react to new market requirements more rapidly and\n fosters the use of automation technologies. This influences the way\n software solutions are built, which is why the concept of\n cloud-native applications has emerged over the last few years to\n build highly scalable applications, and to automatically deploy and\n run them in modern cloud environments. However, there is currently\n no reference work clearly stating the features that a deployment\n technology must offer to support the deployment of arbitrary\n cloud-native applications. In this paper, we derive three essential\n features for deployment technologies based on the current\n cloud-native research and characteristics discussed therein. The\n presented features can be used to compare and categorize existing\n deployment technologies, and they are intended to constitute a first\n step towards a comprehensive framework to assess deployment\n technologies.\n

\n The automation of application deployment is critical because\n manually deploying applications is time-consuming, tedious, and\n error-prone. Several deployment automation technologies have been\n developed in recent years employing tool-specific deployment\n modeling languages. At the same time, the OASIS standard Topology\n Orchestration Specification for Cloud Applications (TOSCA) emerged\n as a means for describing cloud applications, i. e., their\n components and relationships, in a vendor-agnostic fashion. Despite\n TOSCA is widely used in research, it is not supported by the\n production-ready deployment automation technologies daily used by\n practitioners working with cloud-native applications, hence\n resulting in a gap between the state-of-the-art in research and\n state-of-practice in the industry. To help bridging this gap, we\n leverage the recently introduced Essential Deployment Metamodel\n (EDMM) and identify TOSCA Light, an EDMM-compliant subset of TOSCA,\n to enact the transformation from TOSCA to the vast majority of\n deployment automation technology-specific models used by todayâs\n software industry. Further, we present an end-to-end TOSCA Light\n modeling and transformation workflow and show a prototypical\n implementation to validate our approach.\n

\n The term serverless is often used to describe cloud applications\n that comprise components managed by third parties. Like any other\n cloud application, serverless applications are often tightly-coupled\n with providers, their features, models, and APIs. As a result, when\n their portability to another provider has to be assessed,\n application owners must deal with identification of heterogeneous\n lock-in issues and provider-specific technical details.\n Unfortunately, this process is tedious, error-prone, and requires\n significant technical expertise in the domains of serverless and\n cloud computing. In this work, we introduce SEAPORT, a method for\n automatically assessing the portability of serverless applications\n with respect to a chosen target provider or platform. The method\n introduces (i) a canonical serverless application model, and (ii)\n the concepts for portability assessment involving classification and\n components similarity calculation together with the static code\n analysis. The method aims to be compatible with existing migration\n concepts to allow using it as a complementary part for serverless\n use cases. We present an architecture of a decision support system\n supporting automated assessment of the given application model with\n respect to the target provider. To validate the technical\n feasibility of the method, we implement the system prototypically.\n

\n Complex applications are typically composed of multiple components.\n In order to install these components all their dependencies need to\n be satisfied. Typically these dependencies are resolved, downloaded,\n and installed during the deployment time and in the target\n environment, e.g., using package manager of the operating system.\n However, under some circumstances this approach is not applicable,\n e.g., if the access to the Internet is limited or non-existing at\n all. For instance, Industry 4.0 environments often have no Internet\n access for security reasons. Thus, in these cases, deployment\n packages without external dependencies are required that already\n contain everything required to deploy the software. In this paper,\n we present an approach enabling the transformation of\n non-self-contained deployment packages into self-contained\n deployment packages. Furthermore, we present a method for developing\n self-contained deployment packages systematically. The practical\n feasibility is validated by a prototypical implementation following\n our proposed system architecture. Moreover, our prototype is\n evaluated by provisioning a LAMP stack using the open-source\n ecosystem OpenTOSCA.\n

Quantum computing introduces a new computing paradigm that promises to solve problems that cannot be solved by classical computers efficiently. Thus, quantum applications will be more and more integrated in classical applications. To bring these composite applications into production, technologies for an automated deployment and orchestration are required to avoid manual error-prone and time-consuming processes. For non-quantum applications, a variety of deployment technologies have been developed in recent years. However, the deployment of quantum applications currently differs significantly from non-quantum applications and thus, leads to a different modeling procedure for the deployment of quantum applications. To overcome these problems, we propose TOSCA4QC that introduces two deployment modeling styles based on the Topology and Orchestration Specification for Cloud Applications (TOSCA) standard for automating the deployment and orchestration of quantum applications: (i) SDK-specific modeling style to cover all technical deployment details and (ii) SDK-agnostic modeling style supporting common modeling principles. We further show how existing model-driven development (MDD) approach can be applied to refine a SDK-agnostic model to an executable SDK-specific model. We demonstrate the practical feasibility by a prototypical implementation as an extension of the TOSCA ecosystem OpenTOSCA and three case studies with IBMQ and a quantum simulator.

Microservice-based architectures (MSAs) gained momentum in industrial and research communities since finer-grained and more independent components foster reuse and reduce time to market. However, to come from the design of MSAs to running applications, substantial knowledge and technology-specific expertise in the deployment and integration of microservices is needed. In this paper, we propose a model-driven and pattern-based approach for composing microservices, which facilitates the transition from architectural models to running deployments. Using a unified modelling for MSAs, including both their integration based on Enterprise Integration Patterns (EIPs) and deployment aspects, our approach enables automatically generating the artefacts for deploying microservice compositions. This helps abstracting away the underlying infrastructure including container orchestration platforms and middleware layer for service integration. To validate the feasibility of our approach, we illustrate its prototypical implementation, with Kubernetes used as container orchestration system and OpenFaaS used for managing integration logic, and we present a case study.

With the ongoing advances in the area of cloud computing, Internet of Things, Industry 4.0, and the increasing prevalence of cyber-physical systems and devices equipped with sensors, the amount of data generated every second is rising steadily. Thereby, the gathering of data and the creation of added value from this data is getting easier and easier. However, the increasing volume of data stored in the cloud leads to new challenges. Analytics software and scalable platforms are required to evaluate the data distributed all over the internet. But with distributed applications and large data sets to be handled, the network becomes a bottleneck. Therefore, in this work, we present an approach to automatically improve the deployment of such applications regarding the placement of data processing components dependent on the data flow of the application. To show the practical feasibility of our approach, we implemented a prototype based on the open-source ecosystem OpenTOSCA. Moreover, we evaluated our prototype using various scenarios.

\n The current trend of connecting the physical world with the\n so-called cyber world resulted in paradigms such as the Internet of\n Things or the more general paradigm of Cyber-Physical Systems. The\n wide range of domains applicable results in a heterogeneous\n landscape of software and hardware solutions. To benefit of the\n paradigm, developers must be able to integrate different solutions\n from a range of different domains. However, these systems must\n therefore be able to change components, configurations and\n environments, hence, be adaptable at runtime. We present an approach\n that is based on the combination of Situation-Aware Adaptation\n concepts and Deployment Models. The general idea is to start\n processes that can change application structure and configuration\n when a certain situation in the context of applications occur. We\n validated the technical feasibility of our approach by a\n prototypical implementation based on a Smart Home scenario.\n

\n New paradigms such as edge computing opened up new opportunities for\n distributing applications to meet use-case-specific requirements.\n For automating the deployment of applications, deployment models can\n be created that describe the application structure with its\n components and their relations. However, the distribution is often\n not known in advance and, thus, deployment models have to be\n restructured. This can result in problems that have not existed\n before, e.g., components previously deployed in the same network\n were distributed, but security mechanisms are missing. Architecture\n patterns can be used to detect such problems, however, patterns\n describe only generic technology-independent solutions, which cannot\n automatically be applied to applications. Several concrete\n technologies exist that implements the pattern. Which solutions are\n applicable to a particular application is determined by, e.g., its\n hosting environment or used communication protocol. However, the\n manual effort to determine and implement appropriate solutions is\n immense. In this work, we present an approach to automate (i) the\n determination of solutions for an application using first-order\n logic and (ii) the adaptation of its deployment model accordingly.\n To validate the practical feasibility, we present a prototype using\n the cloud standard TOSCA and the logic programming language PROLOG.\n

Blockchains are distributed systems that facilitate the interaction of autonomous entities with limited mutual trust. Many of them support transactional applications known as smart contracts, which access and modify the shared world state. Permissionless blockchains are completely decentralized and do not require mutual trust between interacting peers, but at the expense of having low performance and limited data confidentiality capabilities. On the other hand, permissioned blockchains solve these issues, but sacrifice complete decentralization and involve more trust assumptions. Therefore, there is no single blockchain system suitable for all use-cases. However, this becomes a serious integration challenge for enterprises that need to interact with multiple permissioned and permissionless blockchains in the same context. To facilitate this, we propose an approach that enables composing smart contract functions of various permissioned and permissionless blockchain systems by providing the ability to invoke them directly from business process models using a new task type. To keep this task blockchain-agnostic, we designed a generic technique to identify smart contract functions, as well as a generic metric to describe the degree-of-confidence in the finality of blockchain transactions. Thereby, the proposed approach extends our previous work, BlockME, which provides business modeling extensions only suitable for interacting with permissionless blockchains. To validate the practical feasibility of our approach, we provide a detailed system architecture and a prototypical implementation supporting multiple blockchains.

To automate the deployment of applications several deployment technologies have been developed. However, the management of deployed applications is only partially covered by existing approaches: While management functionalities such as scaling components or changing their configurations are covered directly by cloud providers or configuration management technologies such as Chef, holistic management processes that affect multiple components probably deployed in different environments cannot be automated using these approaches. For example, testing all deployed components and their communication or backing up the entire application state that is scattered across different components requires custom management logic that needs to be implemented manually, e. g., using scripts. However, a manual implementation of such management processes is errorprone, time-consuming, and requires immense technical expertise. Therefore, we propose an approach that enables automatically generating executable management workflows based on the declarative deployment model of an application. This significantly reduces the effort for automating holistic management processes as no manual implementation is required. We validate the practical feasibility of the approach by a prototypical implementation based on the TOSCA standard and the OpenTOSCA ecosystem.

The growing usage of software and hardware in our everyday lives has lead to paradigms such as Cloud Computing, Edge Computing, and the Internet of Things. The combination of these paradigms results in distributed and heterogeneous target environments: components of an application often need to be deployed in different environments such as clouds, private data centers, and small devices. This makes the deployment of distributed applications a complex and error-prone challenge as deployment systems have to (i) support cloud deployments, (ii) determine the location of physical resources, (iii) cope with security mechanisms preventing inbound communication, and (iv) use hardware-constrained devices. In this paper, we present an approach for the automated deployment of distributed applications on heterogeneous target environments consisting of public and private clouds, and devices. We especially tackle the issue of deploying components in environments having restricted inbound communication capabilities. We prototypically implemented and compared our approach based on a smart home scenario using TOSCA and the OpenTOSCA Ecosystem.

Function-as-a-Service (FaaS) is an emerging cloud service model that enables composing applications using arbitrary, small, and event-driven code snippets managed by cloud providers and that can be scaled to zero. The scalability properties of FaaS look attractive for handling rare or unexpected high loads that affect only particular functionalities of the application. However, deciding on the component granularity upfront or reengineering the architecture of an entire application for rare workloads is often a very difficult challenge or even infeasible. In this work, we introduce a method that prepares annotated functionalities for handling rare workloads by automatically extracting them from the source code of the application and additionally deploying them as FaaS functions, while keeping the original application's functionalities and architecture unchanged. In this way, the benefits of FaaS can be leveraged without the need to reengineer the application only for rare cases. We validate our method by means of a prototype, evaluate its feasibility in a set of experiments, and discuss limitations and future work.

\n For Internet of Things (IoT) devices and cyber-physical systems\n (CPS), it is required to connect them securely and reliably to some\n form of cloud environment or computing entity for control,\n management and utilisation. The Internet is a suitable,\n standardized, and proven means for the connection of IoT devices in\n various scenarios. Connection over the Internet utilises existing\n protocols, standards, technologies and avoids investment in new,\n specialised concepts. Thereby, this connection requires a\n transparent addressing schema which is commonly TCP/IP, using domain\n names and IP addresses. However, in industrial, commercial and\n private networks, the addressability and connectability/connectivity\n is often limited by firewalls, proxies and router configurations\n utilising NAT. Thus, the present network configurations hinder the\n spread across different locations. Therefore, the method for\n connecting IoT devices in a client-server configuration proposed\n herein utilises the Tor (previously: The onion router/routing)\n network for addressing of and secured communication to IoT and CPS\n devices. It is an overlay protocol that was designed to allow for\n robust and anonymous communication. The benefit of this approach is\n to enable addressability and connectivity of IoT devices in\n firewalled and potentially unknown and changing network\n environments, thus allowing for IoT devices to be used reliably\n behind firewalls as long as outgoing communication is not blocked.\n

The importance of data is steadily increasing in the domain of business process management due to recent advances in data science, IoT, and Big Data. To reflect this paradigm shift towards data-awareness in service choreographies, we introduced the notion of data-aware choreographies based on concepts for Transparent Data Exchange (TraDE) in our previous works. The goal is to simplify the modeling of business-relevant data and its exchange in choreography models while increasing their run time flexibility. To further improve and simplify the modeling of data-related aspects in service choreographies, in this paper, we focus on the extension of our TraDE concepts to support the modeling of data transformations in service choreographies. Such data transformation capabilities are of dire need to mediate between different data formats, structures and representations of the collaborating participants within service choreographies. Therefore, the paper presents a modeling extension as means for specifying and executing heterogeneous data transformations in service choreographies based on our TraDE concepts.

In recent years, many deployment systems have been developed that process deployment models to automatically provision applications. The main objective of these systems is to shorten delivery times and to ensure a proper execution of the deployment process. However, these systems mainly focus on the correct technical execution of the deployment, but do not check whether the deployed application is working properly. Especially in DevOps scenarios where applications are modified frequently, this can quickly lead to broken deployments, for example, if a wrong component version was specified in the deployment model that has not been adapted to a new database schema. Ironically, even hardly noticeable errors in deployment models quickly result in technically successful deployments, which do not work at all. In this paper, we tackle these issues. We present a modeling concept that enables developers to define deployment tests directly along with the deployment model. These tests are then automatically run by a runtime after deployment to verify that the application is working properly. To validate the technical feasibility of the approach, we applied the concept to TOSCA and extended an existing open source TOSCA runtime.

The increasing amount of gathered sensor data in Industry 4.0 allows comprehensive data analysis software that creates value-adding opportunities. As companies often cannot implement such software by themselves and as they typically don't want to give their data to external scientists, they commission them to build the required software in order to execute it locally. However, installing, configuring, and running complex third party software on another company's infrastructure and linking them to local data sources challenges the responsible administrators due to an immense technical complexity. Moreover, standards-based approaches for automation are missing. In this paper, we present three TOSCA-based deployment modelling approaches for function shipping that enable modelling data analysis software in a way that enables (i) its automated deployment and execution in a remote, foreign IT infrastructure including (ii) the wiring with the data sources that need to be processed in this environment. We validate the practical feasibility of the presented modelling approaches by a case study from the domain of manufacturing, which is based on the open-source TOSCA ecosystem OpenTOSCA, which provides a modelling tool, a runtime, as well as a self-service portal for TOSCA.

In the domain of IoT a major objective is the interconnection of a variety of devices with higher level applications. Therefore, several IoT middleware systems have been developed. These IoT integration middleware systems are heterogeneous, e.g., in terms of the supported transport protocols. Thus, IoT environments often differ due to the utilized middleware. As a result, by deploying applications in different environments the communication clients on the application side have to be adjusted manually. This leads to a greater development effort for each deployment and hampers the application's portability. In this paper, we present a generic driver injection concept to enable the development of portable IoT applications and the automated deployment in different environments without manual adaptation efforts. For this, a programming model and a deployment modeling concept are introduced. We demonstrate the feasibility of our approach with a TOSCA-based prototype.

With Cloud Computing, offering and delivering services over the Internet became commonly feasible. This has impacts on application design, development as well as on the automation of application provisioning. The Twelve-Factor App is a methodology that documents best practices for building and operating scalable, maintainable, and portable web-based SaaS applications. However, a standards-based approach to build, release, and run Twelve-Factor Apps independently of individual cloud providers and specific deployment technologies is missing, which quickly leads to a vendor or technology lock-in. In this paper, we introduce a guideline to establish a development process using the Twelve-Factor App methodology together with the OASIS standard TOSCA to address this issue. We show how to realize the twelve factors with TOSCA and how the approach supports portability and automated deployment.

The automated provisioning and management of Cloud applications is supported by various general-purpose technologies that provide generic management functionalities such as scaling components or automatically redeploying parts of a Cloud application. However, if complex applications have to be managed, these technologies reach their limits and individual, application-specific processes must be created to automate the execution of holistic management tasks that cannot be implemented in a generic manner. Unfortunately, creating such processes from scratch is time-consuming, error-prone, and knowledge-intensive, thus, leading to inefficient developments of new applications. In this paper, we present an approach that tackles these issues by enabling the usage of choreographies to systematically combine available management workflows of existing application building blocks. Moreover, we show how these choreographies can be merged into single, executable workflows in order to enable their automated execution. To validate the approach, we apply the concept to the choreography language BPEL4CHOR and the Cloud standard TOSCA. In addition, we extend the Cloud application management ecosystem OpenTOSCA to support executing management choreographies.

\n Recent efforts to standardize a deployment modeling language for\n cloud applications resulted in TOSCA. At the same time, the software\n modeling standard UML supports architecture modeling from different\n viewpoints. Combining these standards from cloud computing and\n software engineering would allow engineers to refine UML\n architectural models into TOSCA deployment models that enable\n automatic provisioning of cloud applications. However, this\n refinement task is currently carried out manually by recreating\n TOSCA models from UML models because a conceptual mapping between\n the two languages as basis for an automated translation is missing.\n In this paper, we exploit cloud modeling extensions to UML called\n CAML as the basis for our approach CAML2TOSCA, which aims at\n bridging UML and TOSCA. The validation of our approach shows that\n UML models can directly be injected into a TOSCA-based provisioning\n process. As current UML modeling tools lack cloud-based refinement\n support for deployment models, the added value of CAML2TOSCA is\n emphasized because it provides the glue between architecture\n modeling and application provisioning.\n

Shortening software release cycles increasingly becomes a critical competitive advantage, not exclusively for software vendors in the field of Web applications, mobile apps, and the Internet of Things. Today's users, customers, and other stakeholders expect quick responses to occurring issues and feature requests. DevOps and Cloud computing are two key paradigms to enable rapid, continuous deployment and delivery of applications utilizing automated software delivery pipelines. However, it is a highly complex and sophisticated challenge to implement such pipelines by installing, configuring, and integrating corresponding general-purpose deployment automation tooling. Therefore, we present a method in conjunction with a framework and implementation to dynamically generate tailored deployment engines for specific application stacks to deploy corresponding applications. Generated deployment engines are packaged in a portable manner to run them on various platforms and infrastructures. The core of our work is based on generating APIs for arbitrary deployment executables such as scripts and plans that perform different tasks in the automated deployment process. As a result, deployment tasks can be triggered through generated API endpoints, abstracting from lower-level, technical details of different deployment automation tooling.

The automation of business processes is of vital importance for organizations to speed up their business and to lower costs. Due to emerging technologies in the field of Internet of Things, changing situations can be recognized automatically, which provides the basis for an automated adaptation of process executions in order to react to changing circumstances. Although approaches exist that enable creating self-adapting workflows, a systematic modelling approach that supports the specification of situational dependencies directly in workflow models is missing. In this paper, we tackle this issue by presenting a modelling extension called SitME that defines (i) an extensible Situation Event type, (ii) the concept of Situational Scopes, and (iii) a visual notation. As the introduced extension is language-independent, we apply the approach to BPEL to validate its practical feasibility.

Processes involving knowledge workers, such as decision-making processes, research processes, development processes, maintenance processes, etc. play a critical role for many organizations because they represent a valuable amount of the work an organization delivers. Therefore, supporting and automating such processes is vitally important for organizations. In our previous work, we have proposed a resource-centric approach called Informal Process Essentials (IPE) to support and to provide a certain degree of automation. The approach enables specifying required resources including autonomous agents of an informal process for accomplishing process goals through creating and initializing IPE models. Initializing an IPE model results in the acquirement of resources that collaboratively work towards the goals specified by the model. In this work, we provide an approach to automating the enactment of such resource-centric informal processes in two steps: (i) integrating resources of informal processes and (ii) executing informal processes. The approach we introduce enables the inclusion of different resource domains, e.g., IT resources, human resources, etc., and resource deployment environments, e.g., OpenTOSCA, Docker, etc. to model and enact informal processes. During the execution, the resources made available through the integration are acquired and engaged for goals of modeled informal processes. To validate the introduced concepts, we apply the approach to a detailed case study that realizes these two steps based on existing approaches and technologies, in particular, the OpenTOSCA ecosystem, an knowledge base, and an APIfication approach.

Leading paradigms to develop, deploy, and operate applications such as continuous delivery, configuration management, and the merge of development and operations (DevOps) are the foundation for various techniques and tools to implement automated deployment. To make such applications available for users and customers, these approaches are typically used in conjunction with Cloud computing to automatically provision and manage underlying resources such as storage and virtual servers. A major class of these automation approaches follow the idea of converging toward a desired state of a resource (e.g. a middleware component deployed on a virtual machine). This is achieved by repeatedly executing idempotent scripts to reach the desired state. Because of major drawbacks of this approach, we discuss an alternative deployment automation approach based on compensation and fine-grained snapshots using container virtualization. We perform an evaluation comparing both approaches in terms of difficulties at design time and performance at runtime. Moreover, we discuss concepts, strategies, and implementations to effectively combine different deployment automation approaches.

The automation of application management is one of the most important issues in Cloud Computing. However, the steadily increasing number of different services, software components, and dependencies in composite Cloud applications leads to a higher risk of unexpected management side effects when different technologies work together that bring their own proprietary management APIs. Due to unknown dependencies and the increasing diversity and heterogeneity of employed technologies, even small management tasks on single components may compromise the whole application functionality for reasons that are neither expected nor obvious to non-experts. In this paper, we tackle these issues by introducing a method that enables detecting and correcting unintended effects of management tasks in advance by analyzing the context in which tasks are executed. We validate the method practically by showing how context-aware expert management knowledge can be applied fully automatically to running Cloud applications.

There are several script-centric approaches, APIs, and tools available to implement automated provisioning, deployment, and management of applications in the Cloud. The automation of all these aspects is key for reducing costs. However, most of these approaches are script-centric and provide proprietary solutions employing different invocation mechanisms, interfaces, and state models. Moreover, most Cloud providers offer proprietary Web services or APIs to be used for provisioning and management purposes. Consequently, it is hard to create deployment and management plans integrating several of these approaches. The goal of our work is to come up with an approach for unified invocation of scripts and services without handling each proprietary interface separately. A prototype realizes the presented approach in a standards-based manner using the Topology and Orchestration Specification for Cloud Applications (TOSCA).

Human-centric processes are part of most organizations and their execution steps are typically not known initially. Consequently, standard business process modeling approaches are not suitable for modeling informal processes because they typically concentrate on the explicit modeling of the execution steps. In this work, we analyze properties of informal processes and requirements for supporting their correct enactment. We review existing approaches and evaluate their suitability in terms of modeling informal processes. Based on these results, we present a resource-centric approach by employing the concept of Informal Process Essentials which is used to create executable informal process models with dynamically changing interrelated resources.

The automation of application provisioning is one of the most important issues in Cloud Computing. The Topology and Orchestration Specification for Cloud Applications (TOSCA) supports automating provisioning by two different flavors: (i) declarative processing is based on interpreting application topology models by a runtime that infers provisioning logic whereas (ii) imperative processing employs provisioning plans that explicitly describe the provisioning tasks to be executed. Both flavors come with benefits and drawbacks. This paper presents a means to combine both flavors to resolve drawbacks and to profit from benefits of both worlds: we propose a standards-based approach to generate provisioning plans based on TOSCA topology models. These provisioning plans are workflows that can be executed fully automatically and may be customized by application developers after generation. We prove the technical feasibility of the approach by an end-to-end open source toolchain and evaluate its extensibility, performance, and complexity.

Cloud services allow for hosting applications partially or completely in the Cloud by migrating their components and data. Especially with respect to data migration, a series of functional and non-functional challenges like data confidentiality arise when considering private and public Cloud data stores. In this paper we identify some of these challenges and propose a set of reusable solutions focusing on the non-functional aspects, organized together as a set of Cloud Data Patterns.

Simulations are characterized by long running calculations and complex data handling tasks accompanied by non-trivial data dependencies. The workflow technology helps to automate and steer such simulations. Quality of Data frameworks are used to determine the goodness of simulation data, e.g., they analyze the accuracy of input data with regards to the usability within numerical solvers. In this paper, we present generic approaches using evaluated Quality of Data to steer simulation workflows. This allows for ensuring that the predefined requirements such as a precise final result or a short execution time will be met even after the execution of simulation workflow has been started. We discuss mechanisms for steering a simulation on all relevant levels - workflow, service, algorithms, and define a unifying approach to control such workflows. To realize Quality of Data-driven workflows, we present an architecture realizing the presented approach and a WS-Policy-based language to describe Quality of Data requirements and capabilities.

In recent years scientific workflows have been used for conducting data-intensive and long running simulations. Such simulation workflows have processed and produced different types of data whose quality has a strong influence on the final outcome of simulations. Therefore being able to monitor and analyze quality of this data during workflow execution is of paramount importance, as detection of quality problems will enable us to control the execution of simulations efficiently. Unfortunately, existing scientific workflow execution systems do not support the monitoring and analysis of quality of data for multi-scale or multi-domain simulations. In this paper, we examine how quality of data can be comprehensively measured within workflows and how the measured quality can be used to control and adapt running workflows. We present a quality of data measurement process and describe a quality of data monitoring and analysis framework that integrates this measurement process into a workflow management system.