Distributed Software Applications Research Articles

A security testing mechanism for detecting attacks in distributed software applications using blockchain.

Distributed software applications are one of the most important applications currently used. Rising demand has led to a rapid increase in the number and complexity of distributed software applications. Such applications are also more vulnerable to different types of attacks due to their distributed nature. Detecting and addressing attacks is an open issue concerning distributed software applications. This paper proposes a new mechanism that uses blockchain technology to devise a security testing mechanism to detect attacks on distributed software applications. The proposed mechanism can detect several categories of attacks, such as denial-of-service attacks, malware and others. The process starts by creating a static blockchain (Blockchain Level 1) that stores the software application sequence obtained using software testing techniques. This sequence information exposes weaknesses in the application code. When the application is executed, a dynamic blockchain (Blockchain Level 2) helps create a static blockchain for recording the responses expected from the application. Every response should be validated using the proposed consensus mechanism associated with static and dynamic blockchains. Valid responses indicate the absence of attacks, while invalid responses denote attacks.

A formal actor-based model for streaming the future

Asynchronous Actor-based programming has gained increasing attention as a model of concurrency and distribution. The Abstract Behavioral Specification (ABS) language is an actor-based programming language that has been developed for both the modeling and formal analysis of distributed systems. In ABS, actors are modeled as concurrent objects that communicate by asynchronous method calls. Return values are also communicated asynchronously via return statements and so-called futures. Many modern distributed software applications require a form of continuous interaction between their components which consists of streaming data from a server to its clients. In this paper, we extend the ABS language in order to support the streaming of data. We introduce the notion of “future-based data streams” by augmenting the syntax, type system, and operational semantics of ABS. As a proof of concept, we further discuss a prototype implementation for supporting future-based data streams on top of ABS, and discuss the impact of the use of these data streams in ABS on the performance in the implementation of a distributed application for the generation of social networks.

A controller synthesis framework for automated service composition

Nowadays, Web services allow interoperability among distributed software applications deployed on different platforms and architectures which in effect plays a major role in electronic businesses. Web services allow organizations to carry out certain business activities automatically and in a distributed fashion. However, in some circumstances, a single service is not able to perform a certain task and it becomes imperative to compose two or more services in order to complete it. Thus, a key research challenge in this field is the problem of automatic service composition. Several approaches exist that tackle the problem of automatic service composition, however, the task of generating provably correct Web service compositions still remains a challenging and complex task. In this paper, we develop a formal framework for modeling Web service compositions based on Supervisory Control Theory (SCT) of discrete-event systems. We model services that exchange messages and exhibit nondeterministic behaviours. The objective is to synthesize a supervisor which interacts with a given set of Web services through messages to guarantee that a given specification is satisfied. A key novelty of this work is the application of control theory to service-oriented computing and the incorporation of run-time input into the supervisor generation process. First, we describe a novel supervisory control framework for automated composition of Web services. The framework employs Labelled Transition Systems equipped with guards and data variables to model Web services and provides a technique to synthesize a controller. We model the interactions of services asynchronously and we use the guards and data variables to allow us to express certain preconditions which are then propagated from the system requirements through the overall composite service. Second, we develop a set of algorithms to generate a controller satisfying a given functional requirement also specified as a Labelled Transition System equipped with guards and data variables. Besides the standard disabling and enabling of events, the generated controller in our framework has the ability to enforce certain events based on run-time information to drive the system towards its goal. In addition, the controller is able to impose restrictions on the kind of data that can be sent or received by services. This includes the automatic generation of stronger guards or preconditions which impose restrictions on which path to take during execution. Lastly, we state a theorem capturing the existence of a controller and provide a proof to demonstrate the correctness of the proposed approach.

Java Message Service Based Performance Comparison of Apache ActiveMQ and Apache Apollo Brokers

Software integration is a crucial aspect of collaborative software applications and systems. It enables a number of different software applications, created by different developers, using different programming languages, and even located at different places to work with each other collaboratively to achieve common goals. Nowadays, a number of techniques are available to enable software integration. Messaging is the most prominent technique in this respect. In this paper, two leading open-source messaging brokers, Apache ActiveMQ and Apache Apollo, have been experimentally compared with each other with regard to their messaging capabilities (message sending and receiving throughputs). Both brokers support exchanging messages between heterogeneous and distributed software applications using several messaging mechanisms including Java Message Service (henceforth JMS). A number of experimental test scenarios have been conducted to obtain the comparison results that indicate the one-to-one JMS messaging performance of each broker. Overall performance evaluation and analysis showed that Apache Apollo outperformed Apache ActiveMQ in all test scenarios regarding message sending throughputs. Whereas, Apache ActiveMQ outperformed Apache Apollo in most test scenarios regarding message receiving throughputs. Moreover, the evaluation methodology (test conditions, test scenarios, and test metrics) proposed in this paper has been carefully chosen to be adopted by software developers to evaluate other messaging brokers to determine the acceptable level of messaging capabilities in distributed environments of heterogeneous software applications.

Recent advances in interactive and automated analysis

Computers and distributed software applications are becoming nowadays ubiquitous, and therefore their safety and reliability have increasingly important societal impact. In this context, formal methods equipped with powerful and versatile analysis tools are more important than ever in the design process. Despite the relevant scientific results and well-established tools obtained in recent years, there is a constant need of enhancing the analysis capabilities in order to handle increasingly complex systems. We briefly discuss some recent advances in the field, introducing five papers selected from the 22th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS 2016).

Virtualizing Lifemapper software infrastructure for biodiversity expedition

SummaryOne of the activities of the Pacific Rim Applications and Grid Middleware Assembly (PRAGMA) is fostering Virtual Biodiversity Expeditions by bringing domain scientists and cyber infrastructure specialists together as a team. Over the past few years, PRAGMA members have been collaborating on virtualizing the Lifemapper software. Virtualization and cloud computing have introduced great flexibility and efficiency into IT projects. Virtualization refers to the technologies that provide a layer of abstraction between server hardware system and software that runs on it. This abstraction enables a logical view of computing resources and allows multiple servers to run on the same hardware. With this project, we are virtualizing Lifemapper by enabling its installation and configuration on a virtual cluster. Virtualization provides application scalability, maximizes resources utilization, and creates a more efficient, agile, and automated infrastructure. However, there are downsides to the complexity inherent in these environments, including the need for special techniques to deploy cluster hosts, dependence on virtual environments, and challenging application installation, management, and configuration. In this study, we report on progress of the Lifemapper virtualization framework focused on a reproducible and highly configurable infrastructure capable of fast deployment.Lifemapper is a distributed software application developed by the Biodiversity Institute at The University of Kansas. Lifemapper creates and maintains a publicly accessible archive of species distribution maps calculated from public specimen data. Lifemapper software also provides a suite of tools for biodiversity researchers that calculate single and multispecies distribution predictions and macroecological analyses through application programming interfaces. Our goal is to create a viable solution that can be easily adopted and reused by scientists from multiple institutions or projects. This solution (1) allows fast deployment of ready‐made cluster images, (2) reproduces the complete Lifemapper processing pipeline on demand at multiple sites and in different hosting environments, and (3) enables scientists to perform Lifemapper‐facilitated data processing on restricted‐use data, very large datasets, or other unique data.A key contribution of this work is describing the practical experience in taking a complex, clustered, domain‐specific, data analysis, and simulation system and enabling its operation on a variety of system configurations. Uses of this portability range from whole cluster replication to teaching and experimentation on a single laptop. System virtualization is used to practically define and make portable the full application stack, including all of its complex set of supporting software and allows Lifemapper deployment in a variety of environments.

A Web Service Discovery Approach Based on Common Topic Groups Extraction

Web services have attracted much attention from distributed application designers and developers because of their roles in abstraction and interoperability among heterogeneous software systems, and a growing number of distributed software applications have been published as Web services on the Internet. Faced with the increasing numbers of Web services and service users, researchers in the services computing field have attempted to address a challenging issue, i.e., how to quickly find the suitable ones according to user queries. Many previous studies have been reported towards this direction. In this paper, a novel Web service discovery approach based on topic models is presented. The proposed approach mines common topic groups from the service-topic distribution matrix generated by topic modeling, and the extracted common topic groups can then be leveraged to match user queries to relevant Web services, so as to make a better trade-off between the accuracy of service discovery and the number of candidate Web services. Experiment results conducted on two publicly-available data sets demonstrate that, compared with several widely used approaches, the proposed approach can maintain the performance of service discovery at an elevated level by greatly decreasing the number of candidate Web services, thus leading to faster response time.

Probabilistic Models Toward Controlling Smart-* Environments

Today, a growing number of physical objects in our surroundings are connected to the Internet and provide the digital world with an interface to the physical world through sensors and actuators . At the heart of this trend, smart-* systems and applications leverage this interface to smartly and seamlessly assist individuals in their everyday lives. However, when interacting with the physical world by means of actuators, these applications introduce a methodological disruption. Indeed, in comparison to the classical distributed software applications that operate in the bounded and predictable digital world, these applications operate in and through the physical world, open and subject to uncertainties that cannot be modeled accurately. These uncertainties lead the behavior of the applications to potentially drift at runtime, compromising their intrinsic functionality. In this paper, we propose a framework to estimate the behavioral drift of smart-* systems and applications at runtime. To this end, we first rely on the Moore finite state machine (FSM) modeling framework. This framework is used for specifying the ideal behavior of a smart-* application in terms of the effects , and it is expected to produce within the physical environment as it executes. We then appeal on the control theory and propose a framework for projecting the Moore FSM to its associated continuous density Input/Output hidden Markov model (CD-IOHMM) state observer . By accounting for uncertainties through probabilities , it extends Moore FSM with viability zones , i.e., zones where the effects of a smart-* application within the physical environment are satisfactory without necessarily being perfect. At runtime, the CD-IOHMM state observer can compute the probability of the observed effects, i.e., it gives direct insight into the behavioral drift of the concrete application. We validate our approach on a real data set. The results demonstrate the soundness and efficiency of the proposed approach at estimating the behavioral drift of smart-* applications at runtime. In view of these results, one can envision using this estimation for supporting a decision-making algorithm (e.g., within a self-adaptive system).

Decentralisation, Distrust & Fear of the Body – The Worrying Rise of Crypto-Law

By Alan Cunningham. The increasing collective use of distributed application software platforms, programming languages and crypto-currencies around the blockchain concept for general transactions may have radical implications for the way in which society conceptualises and applies trust and trust-based social systems such as law. By exploring one iteration of such generalised blockchain systems – Ethereum – and the historical lineage of such systems, it will be argued that indeed their ideological basis is largely one of distrust, decentralisation and, ultimately, via increasing disassociation of identity, a fear of the body itself. This ideological basis can be reframed as a crypto-legal approach to the problems of human interaction, one whereby the purely technological solutions outlined above are considered adequate for reconciling many of the problems of our collective existence. The article concludes, however, by re-iterating a perspective of law more so as an entirely embodied and trust dependent notion. These aspects go some way to explaining the necessarily centralised role it takes on within societies. They also explain why the crypto-legal approaches advanced by systems like Ethereum – or even the co-opting of blockchain technology by law firms themselves – will only ever be at best efficiency exercises concerned with the processing of data relating to legal affairs, and not the more radical, ambiguous and difficult process of actual legal thought or, indeed, engagement with trust.

An Analysis of Performance Testing in Distributed Software Applications

An Analysis of Performance Testing in Distributed Software Applications

An automatic trace based performance evaluation model building for parallel distributed systems (abstracts only)

Performance models can be built at early stages of software development cycle to aid software designers to assess design alternatives and identify fundamental design pitfalls before the implementation phase starts. These models are flexible for varying operational conditions and design alternatives; however, their creation is not trivial and requires considerable efforts. This paper addresses this problem by introducing automation in process of Layered Queuing Network (LQN) performance model creation for traces of events generated from instrumented software programs in the nodes of a distributed parallel software application. The event-traces are created based on a new timestamp format, which is independent of physical time and uses extremely low count elements. A set of post-mortem methodologies have been introduced to identify the interactions between the service nodes of the parallel distributed software application and determine their workload activities, while supporting concurrent executions in the nodes. It can capture Forward, Asynchronous, Synchronous and loops of Asynchronous or Forward interactions. The final result is a framework of methodologies, specifications and tools which is appropriate for model-based performance evaluation parallel distributed software applications.

Abstract only

Performance models can be built at early stages of software development cycle to aid software designers to assess design alternatives and identify fundamental design pitfalls before the implementation phase starts. These models are flexible for varying operational conditions and design alternatives; however, their creation is not trivial and requires considerable efforts. This paper addresses this problem by introducing automation in process of Layered Queuing Network (LQN) performance model creation for traces of events generated from instrumented software programs in the nodes of a distributed parallel software application. The event-traces are created based on a new timestamp format, which is independent of physical time and uses extremely low count elements. A set of post-mortem methodologies have been introduced to identify the interactions between the service nodes of the parallel distributed software application and determine their workload activities, while supporting concurrent executions in the nodes. It can capture Forward, Asynchronous, Synchronous and loops of Asynchronous or Forward interactions. The final result is a framework of methodologies, specifications and tools which is appropriate for model-based performance evaluation parallel distributed software applications.

Separating Agent-Functioning and Inter-Agent Coordination by Activated Modules: The DECOMAS Architecture

The embedding of self-organizing inter-agent processes in distributed software applications enables the decentralized coordination system elements, solely based on concerted, localized interactions. The separation and encapsulation of the activities that are conceptually related to the coordination, is a crucial concern for systematic development practices in order to prepare the reuse and systematic integration of coordination processes in software systems. Here, we discuss a programming model that is based on the externalization of processes prescriptions and their embedding in Multi-Agent Systems (MAS). One fundamental design concern for a corresponding execution middleware is the minimal-invasive augmentation of the activities that affect coordination. This design challenge is approached by the activation of agent modules. Modules are converted to software elements that reason about and modify their host agent. We discuss and formalize this extension within the context of a generic coordination architecture and exemplify the proposed programming model with the decentralized management of (web) service infrastructures.

Towards runtime discovery, selection and composition of semantic services

Service-orientation is gaining momentum in distributed software applications, mainly because it facilitates interoperability and allows application designers to abstract from underlying implementation technologies. Service composition has been acknowledged as a promising approach to create composite services that are capable of supporting service user needs, possibly by personalising the service delivery through the use of context information or user preferences. In this paper we discuss the challenges of automatic service composition, and present DynamiCoS, which is a novel framework that aims at supporting service composition on-demand and at runtime for the benefit of service end-users. We define the DynamiCoS framework based on a service composition life-cycle. Framework mechanisms are introduced to tackle each of the phases and requirements of this life-cycle. Semantic services are used in our framework to enable reasoning on the service requests issued by end-users, making it possible to automate service discovery, selection and composition. We validate our framework with a prototype that we have built in order to experiment with the mechanisms we have designed. The prototype was evaluated in a testing environment using some use case scenarios. The results of our evaluation give evidences of the feasibility of our approach to support runtime service composition. We also show the benefits of semantic-based frameworks for service composition, particularly for end-users who will be able to have more control on the service composition process.

A Methodology for Architectural Design of Concurrent and Distributed Software Systems

Concurrent and distributed software applications are complex software systems that exploit highly parallel and distributed infrastructure to improve the quality of systems in cost-effective way. In order to assist the development of affordable concurrent and distributed software systems, a more effective approach of utilizing single-based architectural description languages (ADLs) is needed. In this paper, we describe an architectural modeling framework that can be used for specifying and analyzing distributed and concurrent software applications. Our key contribution is an architectural specification framework that integrates four important concepts: (1) an architectural description language known as syntactic theory (ST), (2) a high level Petri nets modeling language known as Hierarchical Predicate Transition Nets (HPrTNs), (3) a Pattern-Based Refinement Technique (PBRT), and (4) a systematic process for deriving architectural specifications from requirement specifications. Moreover, the method is heterogeneous modeling approach that specifies software architecture of a distributed and concurrent system in a top-down manner. The immediate benefits of our heterogeneous approach include: increased system analyzability, comprehensibility, reusability, and flexibility. We describe a case study to show the applicability of our approach.

A Preliminary Study of Suppressing Redundant Nested Invocations from a Web Service with Active Replication

Zwass (1996) suggested that middleware and message service is one of the five fundamental technologies used to realize electronic commerce (EC). The Simple Object Access Protocol (SOAP) is recognized as a more promising middleware for EC applications among other leading candidates such as CORBA. We notice that the fault-tolerance issue is somewhat neglected in the current standard, that is, SOAP 1.1. We therefore proposed a fault tolerant Web service called fault-tolerant SOAP or FT-SOAP through which Web services can be built with higher resilience to failure. Active replication is a common approach to building highly available and reliable distributed software applications. The redundant nested invocation (RNI) problem arises when servers in a replicated group issue nested invocations to other server groups in response to a client invocation. In this work, we propose a mechanism to perform auto-suppression of redundant nested invocation in an active replication FT-SOAP system. Our approach ensures the portability requirement of a middleware, especially for FT-SOAP. The current design of the suppression mechanism itself does not consider the fault-tolerance issue. In other words, it suffers from the single-point of failure. Furthermore, the preliminary performance results indicates significant performance penalty due to inefficient SOAP invocations. More comprehensive experiments are needed to further investigate the feasibility of the current approach in the context of system performance.

Early performance testing of distributed software applications

Performance characteristics, such as response time, through put and scalability, are key quality attributes of distributed applications. Current practice, however, rarely applies systematic techniques to evaluate performance characteristics. We argue that evaluation of performance is particularly crucial in early development stages, when important architectural choices are made. At first glance, this contradicts the use of testing techniques, which are usually applied towards the end of a project. In this paper, we assume that many distributed systems are built with middleware technologies, such as the Java 2 Enterprise Edition (J2EE) or the Common Object Request Broker Architecture (CORBA). These provide services and facilities whose implementations are available when architectures are defined. We also note that it is the middleware functionality, such as transaction and persistence services, remote communication primitives and threading policy primitives, that dominate distributed system performance Drawing on these observations, this paper presents a novel approach to performance testing of distributed applications. We propose to derive application-specific test cases from architecture designs so that performance of a distributed application can be tested using the middleware software at early stages of a development process. We report empirical results that support the viability of the approach.

A model for availability analysis of distributed software/hardware systems

System availability is a major performance concern in distributed systems design and analysis. A typical kind of application on distributed systems has a homogeneously distributed software/hardware structure. That is, identical copies of distributed application software run on the same type of computers. In this paper, the system availability for this type of system is studied. Such a study is useful when studying optimal testing time or testing resource allocation. We consider both the case of simple two-host system, and also the more general case of multi-host system. A Markov model is developed and equations are derived to obtain the steady-state availability. Both software and hardware failures are considered, assuming that software faults are constantly being identified and removed upon a failure. Although a specific model for software reliability is used for illustration, the approach is a general one. Comparisons show that system availability changes in a similar way to single-host based software/hardware systems. Sensitivity analysis is also presented. In addition, the assumptions used in this paper are discussed.

Cross-platform integration with XML and SOAP

The current rage for middleware has provided tremendous opportunities for those who love to build complex distributed software applications. Interoperability is no longer a fringe movement; it's become mainstream. The big three-Microsoft, IBM, and Sun Microsystems-are now investing considerable resources into interoperability research. I tackle the abstract concept of software interoperability and how the Extensible Markup Language (XML) and Simple Object Access Protocol (SOAP) can assist in integrating business applications. Together with the concept of Web services, these standards could provide an alternative to what organizations do today: rely on the batch export of data to integrate software applications.

Suitability of the time controlled environment for race detection in distributed applications

The paper considers testing problem of time dependent errors detection in distributed applications. We determine time conditions for race occurrence and show how to obtain them in distributed environment. Then race detection testing strategies (RDS) following from the concept of a time controlled environment (TCE) is presented. Besides, we prepared some experiments to evaluate suitability of TCE and capability of RDS for improving reliability of distributed software applications.