Edge and fog computing are models to develop internet of things (IoT) solutions with mobility, location awareness, low latency and that allow the processing of large amount of data. Distributed ledger technologies (DLT), such as blockchain, improve IoT system interoperability by enabling a more secure and decentralized way to share data. Recent research has pointed out that integrating current paradigms such as edge/fog and DLT/blockchain allows the development of responsive and secure IoT solutions. Despite recent advances in edge/fog platforms, the current modeling tools are adapted to evaluate edge/fog solutions in limited environments with no DLT/blockchain support. This paper presents an extensible toolset integration to enable edge/fog-based DLT testbeds in virtualized environments. The proposed architecture extends Fogbed to allow the deployment and testing of real-world Edge/Fog-DLT solutions in a scalable way. A case study to demonstrate the emulation and benefits of Edge/Fog-DLT systems is presented. Furthermore, future developments and research directions are discussed.

In spite of the importance of dynamic distributed environments, e.g., SANs (storage area networks), multicore architectures, etc., we found very few proposals of models and protocols for implementing eventual leader election in these contexts. This abstraction is fundamental to ensure consistency and fault-tolerance. Most approaches for electing a leader consist of static systems, in which processes communicate by message passing, satisfying timing constraints. This paper presents an Omega (or Ω) class leader election service for a dynamic asynchronous system subject to crash failures, in which processes communicate through shared memory, following a memory access pattern, free of temporal requirements.

The fog computing paradigm extends cloud resources near data sources to overcome limitations of cloud-based IoT centralized architectures. Its involve the running of services and applications on the nodes between the IoT devices and the cloud. The prototyping and testing of these distributed software is challenging due to the fact that not only the fog service has to be tested but also its integration with management systems. Despite recent advances in fog platforms, there exists no readily available testbed which can help researchers to design and test real world fog applications. To this purpose, network simulators and cloud middleware are adapted to enable the investigation of fog solutions. This paper presents Fogbed, a framework and toolset integration for rapid prototyping of fog components in virtualized environments. Using a desktop approach, Fogbed enables the deployment of fog nodes as software containers under different network configurations. Its design meets the requirements of low cost, flexible setup and compatibility with real world technologies. Unlike current approaches, the proposed framework allows for the testing of fog components with third-party systems through standard interfaces. A scheme to observe the behavior of the environment is provided. A case study is presented to demonstrate a fog service analysis. In addition, future developments and research directions are discussed.

The Internet of Things is composed of smart objects having the ability to communicate and send information about themselves and the environment in which they are inserted. In order to achieve this, a series of communication patterns and electronic components, most of the times incompatible with each other, are used. To solve this problem of uniform management of objects, including their tracking and autonomous monitoring, this work proposes a service-oriented middleware, with support for ontology, REST architectural style and communication by message exchange. This middleware has the innovative feature of taking decisions, recognizing situations, triggering alarms, sending and receiving information by exchanging messages with applications or client software.

The fog computing model integrates cloud services into the network on a widely distributed level to overcome challengers of cloud-based IoT platforms. The deployment of IoT solutions employing a fog architecture requires a decentralized and scalable computing infrastructure, which places networking, compute and storage resources in a hierarchy of levels arranged between the data source and the cloud. Despite recent advances in fog platforms, there exists no readily available testbed which can help researchers to design and evaluate fog applications on a truly IoT scale. The current fog prototyping tools are adapted from cloud middleware or network simulators to enable the evaluation of fog solutions in limited environments. This paper presents a framework and toolset integration that uses the Fogbed emulator to enable fog distributed testbeds in virtualized environments. Unlike current approaches, the proposed framework allows for the deployment and testing of fog components in a scalable way. Its design is compatible with real world technologies and meets the requirements of low cost, flexible setup and supports third-party systems through standard interfaces. A case study is presented to demonstrate the emulation of fog distributed components and services using a cluster approach. In addition, future developments and research directions are discussed.

Consensus is a fundamental building block to solve many practical problems that appear on reliable distributed systems. In spite of the fact that consensus is being widely studied in the context of standard networks, few studies have been conducted in order to solve it in dynamic and self-organizing systems characterized by unknown networks. While in a standard network the set of participants is static and known, in an unknown network, such set and number of participants are previously unknown. This work studies the problem of Byzantine Fault-Tolerant Consensus with Unknown Participants, namely BFT-CUP. This new problem aims at solving consensus in unknown networks with the additional requirement that participants in the system may behave maliciously. It presents the necessary and sufficient knowledge connectivity conditions in order to solve BFT-CUP under minimal synchrony requirements. In this way, it proposes algorithms that are shown to be optimal in terms of synchrony and knowledge connectivity among participants in the system.

Quorum systems are useful tools for implementing consistent and available storage in the presence of failures. These systems usually comprise a static set of servers that provide a fault-tolerant read/write register accessed by a set of clients. We consider a dynamic variant of these systems and propose FreeStore, a set of fault-tolerant protocols that emulates a register in dynamic asynchronous systems in which processes are able to join/leave the servers set during the execution. These protocols use a new abstraction called view generators, that captures the agreement requirements of reconfiguration and can be implemented in different system models with different properties. Particularly interesting, we present a reconfiguration protocol that is modular, efficient, consensus-free and loosely coupled with read/write protocols, improving the overall system performance.

The shared memory model matches important classes of modern applications, such as fault-tolerant and highly available data centric services. Consensus is an important building block able to realize such reliable distributed systems. However, there exists no deterministic solution to consensus in asynchronous systems prone to failures. Failure and leader detectors are elegant abstractions which encapsulate the extra synchrony necessary to circumvent this impossibility. In this paper, we present a generic consensus algorithm for asynchronous shared memory systems able to be instantiated with two fundamental detectors, namely ◇S and Ω. The algorithm is wait-free, tolerating up to n - 1 failures, and optimal, regarding the synchrony required and the number of registers it uses.

The shared memory model matches important classes of systems deployed over dynamic networks, as for example, fault-tolerant and high available data centric services. Consensus is a fundamental building block able to realize such reliable distributed systems. Unlike the classical setting where the full set of participants and their identities are known to every process, dynamic networks preclude such global knowledge to be available. In this paper, we investigate and present protocols to solve fault-tolerant consensus in an environment with unknown participants that communicate via shared memory.

The distributed computing scenario is rapidly evolving for integrating self-organizing and dynamic wireless networks. Unreliable failure detectors (FDs) are classical mechanisms that provide information about process failures and can help systems to cope with the high dynamics of these networks. A number of failure detection algorithms have been proposed so far. Nonetheless, most of them assume a global knowledge about the membership as well as a fully communication connectivity; additionally, they are time-based, requiring that eventually some bound on the message transmission will permanently hold. These assumptions are no longer appropriate to the new scenario. This paper presents a new FD protocol that implements a new class of detectors, namely ⋄ Sℳ, which adapts the properties of the ⋄ S class to a dynamic network with an unknown membership. It has the interesting feature of being time-free, so that it does not rely on timers to detect failures; moreover, it tolerates the mobility of nodes and message losses.

In self-organizing systems, such as mobile ad-hoc and peer-to-peer networks, consensus is a fundamental building block to solve agreement problems. It contributes to coordinate actions of nodes distributed in an ad-hoc manner in order to take consistent decisions. It is well known that in classical environments, in which entities behave asynchronously and where identities are known, consensus cannot be solved in the presence of even one process crash. It appears that self-organizing systems are even less favorable because the set and identity of participants are not known. We define necessary and sufficient conditions under which fault-tolerant consensus become solvable in these environments. Those conditions are related to the synchrony requirements of the environment, as well as the connectivity of the knowledge graph constructed by the nodes in order to communicate with their peers.

Consensus services have been recognized as fundamental building blocks for fault-tolerant distributed systems. Many different protocols to implement such a service have been proposed, however, not a lot of effort has been placed in evaluating their performance. In particular, in the context of round-based consensus protocols for asynchronous systems augmented with failure detectors, there has been some work on evaluating how the QoS of the failure detector impacts the performance of the protocols, as well as on the trade-off between having faster decentralized decision at the expenses of generating more network load. These studies, however, focus on protocols that have no mechanism to deal with an eventual bad QoS provided by the failure detector, and have a decision pattern that is either completely centralized - only one process being able to autonomously decide - or completely decentralized - all processes being able to autonomously decide. This paper reports a thorough evaluation of the performance of a consensus protocol that has two unique features. Firstly, it mitigates the problems due to bad QoS delivered by the failure detector by allowing processes to simultaneously participate in multiple rounds. Secondly, it allows its decision pattern to be configured to have different numbers of processors allowed to autonomously decide. We have measured the decision latency of the protocol to conduct the performance analysis. The results, obtained by means of simulation, highlight the advantages and limitations of the two mechanisms and allow one to understand in a comprehensive framework how the protocol's parameters should be set, such that the best performance is achieved depending on the application's requirements.

This paper evaluates how well a significant number of broadcasting protocols for MANETs behave when under a realistic scenario of momentary failures and topology changes, which is represented by an omission fault model. Reliable protocols which use additional mechanisms to ensure higher delivery rates beyond best- effort guarantees - have been proposed, but they exhibit unacceptably high end-to-end delays. As a result of the study conducted, a new mechanism that helps to enhance the reliability of deterministic broadcasting protocols is proposed. The mechanism allows for scalability, and is capable of ensuring good delivery rates (in spite of failures) while maintaining lower end-to-end delays. Simulation results demonstrate the efficacy of the mechanism.

This paper presents the design of OPEN EDEN, an imple-mentation of the Fault Tolerant CORBA specification based on the use of a group communication system, called EDEN. The design of OPEN EDEN has been driven by the desire to use only portable techniques (mainly portable intercep-tors) to implement the interaction between the EDEN group communication system and CORBA. The EDEN system it-self is built by configuring, assembling and deploying com-ponents connected to a generic agreement component that implements a consensus algorithm. The resulted platform is particularly portable, since it can be easily migrated to d-ifferent architectures, and transparent for applications pro-grammers, since requests to a replicated service are trans-parently intercepted and redirected to the EDEN system. We discuss the main difficulties we encountered and we draw some conclusions about the adequacy of our choices.

Considers the priority inversion problem in an actively replicated system. Priority inversion was originally defined in the context of nonreplicated systems. Therefore, we first introduce the concept of group priority inversion, which extends the concept of (local) priority inversion to the context of a group of processors that perform an actively replicated processing. We then present the properties of a request scheduling protocol to enforce a total ordering for the processing of requests while avoiding group priority inversions. These properties have been implemented in a protocol that relies on a timed asynchronous system model equipped with a failure detector of the class /spl diams/S. The proposed solution allows us to replicate a critical server while ensuring that the processing of all the incoming requests is consistent (mechanisms for solving the atomic broadcast problem) and predictable (mechanisms for solving the group priority inversion problem). Thus, the described request scheduling protocol is a key component which can be used to develop fault-tolerant real-time applications in a timed asynchronous system.

We consider the priority inversion problem in an actively replicated system. Priority inversion was originally defined in the context of non-replicated systems. Therefore we first introduce the concept of group priority inversion, which extends the concept of (local) priority inversion to the context of a group of processors that perform an actively replicated processing. We then present the properties of a request scheduling protocol to enforce a total ordering for the processing of requests while avoiding group priority inversions. These properties have been implemented in a protocol that relies on a timed asynchronous system model equipped with a failure detector of the class /spl square/S. The proposed solution allows one to replicate a critical server while ensuring that the processing of all the incoming requests is consistent (mechanisms for solving the atomic broadcast problem) and predictable (mechanisms for solving the group priority inversion problem). Thus, the described request scheduling protocol is a key component which can be used to develop fault tolerant real time applications in a timed asynchronous system.

Group-based computing is becoming more and more popular when one has to design middleware able to support reliable distributed applications. This paradigm is made of two basic services, namely, a group membership service and a group communication service. More generally, a group is a set of processes cooperating to carry out a common task (e.g., copies of a replicated server, participants in a transaction or users in a CSCW-based application). Due to the desire of new processes to join the group, to the desire of a group member to leave it, or to process crashes, the composition of a group can evolve dynamically. The set of processes that currently implements the group is called the current view of the group. This paper addresses the specification and the implementation of a primary component group membership service. Primary component means that the specification imposes to have a single view at any time. The paper first proposes a specification for the problem. Then it presents a protocol that implements that specification in asynchronous distributed systems equipped with failure detectors. This primary component group membership protocol is obtained as an appropriate instantiation of a general agreement framework.

Presents a framework for the development of higher level communication protocols that provides extra functionalities not supplied by standard off-the-shelf lower level communication protocols. The framework is based on the event channel abstraction which allows circumventing the main drawbacks of the layered-based approach traditionally used to develop such protocols, whilst at the same time providing a flexible, simple and well structured way to implement them. The event channel service provided by EVA establishes how entities that share the same address space interact. Then, the application designer has the opportunity to define the most appropriate lower level communication protocols that control the way entities that execute within different processes will interact. The framework specifies a way to accommodate these protocols and provides several standard protocol implementations. Further a development methodology is described for constructing applications on top of the framework. In designing the framework, we have followed the approach of using, whenever possible, well established concepts, thus the paper also discusses the utilisation of such concepts in improving both the efficiency and the structuring of the framework and of the applications to be built on top of it.

The class of strong failure detectors (denoted S) includes all failure detectors that suspect all crashed processes and that do not suspect some (a priori unknown) process that never crashes. So, a failure detector that belongs to S is intrinsically unreliable as it can arbitrarily suspect correct processes.