On the financial side, a key factor for the success of a smart-city initiative is the low cost of the sensors. On the technical side, the units need to be flexible enough to cover different roles, and to be reconfigurable for a distinct target. The capability to interact with an already deployed infrastructure, like a preexistent web-server, is a favorable feature from both the financial and technical point of view. In this paper we exploit an overlooked feature of the ESP8266 WiFi chip, i.e. the AT commands interpreter, to implement a sensor/actuator that meets the above specifications. To test our design, we implement a library that provides a transparent wrapper for AT commands. Using a prototype consisting of a board hosting an ESP01 coupled with an Arduino Nano, of which the cost is around 10 Euros, we evaluate the static properties and the operational stability.

The infrastructure that supports the Internet of Things (IoT) is a critical component and major ICT industries are ready to propose their solutions. This paper is an attempt to define an approach based on the principles of openness and expandability. Our proposal encompasses both the application level interface of the IoT infrastructure, which allows interaction with external applications, and the interface offered by the single components of the infrastructure, which allows interaction and coordination between the components. In both cases we adopt an REST approach using HTTP for communication. Our purpose is to contribute to the production of a standard for IoT infrastructures and components, to foster an open competition in a fast growing market.

The paper describes a monitoring system specially designed for cloud infrastructures. The features that are relevant for such distributed application are -) scalability, that allows utilization in systems of thousands of nodes, -) flexibility, to be customized for a large number of applications, -) openness, to allow the coexistence of user and administration monitoring. We take as a starting point the Nagios monitoring system, that has been successfully used for Grid monitoring and is still used for clouds. We analyze its shortcomings when applied to cloud monitoring, and propose a new monitoring system, that we call Rocmon, that sums up Nagios experience with a cloud perspective. Like Nagios, Rocmon is plugin-oriented to be flexible. To be fully inter-operable and long-living, it uses standard tools: the OGF OCCI for the configuration interface, the REST paradigm to take advantage of Web tools, and HTML5 WebSockets for data transfers. The design is checked with an open source Ruby implementation featuring the most relevant aspects.

The paper addresses the definition of an ontology for cloud monitoring activities, with the aim of defining a standard interface for their configuration. To be widely adopted, such ontology must be extremely flexible, coping with a wide range of use cases: from the minimalist plug-and-play user, to the one governing a complex infrastructure. Our work is based on the Open Cloud Computing Interface, that is an open, community driven OGF standard allowing boundary-level interfaces to be built using RESTful patterns over HTTP. Among others, OpenStack and OpenNebula adopt OCCI. Using the OCCI ontology we define two kinds that are associated with the basic components of a monitoring infrastructure: the collector link, that performs measurements, and the sensor resource, that aggregates data and undertakes actions. This paper is a compact and self-contained revision of a document currently under discussion inside the OCCI community.

The problem of rollback recovery is traditionally approached using a model oriented to packet delivery. Instead, we introduce a model centered around complex sessions, and we explain why this model is more appropriate. Using this model, we extract a basic coordination scheme that is common to the three distributed activities that compose rollback recovery: checkpointing, rollback and disposal. The basic coordination scheme is refined to describe each of the three activities.

There is a diffused feeling that the self-stabilization concept, as defined by Dijkstra in 1974, is extremely deep in pointing out the features of a fault tolerant distributed system, but is also too restrictive in the definition of what is self-stabilizing.My primary purpose is to explain why Dijkstra's definition needs to be extended: the reader understands that the task is extremely delicate, since there is a unanimous appreciation of the original definition of self-stabilization, and its modification should exhibit extremely strong motivations. Secondarily, we show how it can be modified to widen its applicability.First I restate the original definition using Chandy and Misra's Unity. This step is mechanical, so to keep the result as independent as possible from any subjective understanding of the self-stabilization concept:DEFINITION 1 (SELF-STABILIZING SYSTEM). Given a (flat) Unity program P with guards P and a predicate l, P is self-stabilizing to l if and only if:the initially section of P is empty, unconditionall is stable, stability∀p ∈ P, {l ∧ p} ≠ 0, minimal statements∀x, y ∈ {l}, x m y, minimal statestrue m l.finite convergenceThe label attached to each predicate may help intuition. The next theorem, whose proof is in the full paper that can be requested by e.mail, limits the set of problems that can be treated with self-stabilization:THEOREM 1. A predicate l satisfies stability and minimal states if and only ifonly one state satisfies l and the execution of any statement leaves that state unaltered orthere are n > 1 states that satisfy l and an indexingl} = {s0,…,sn - 1} exists such that si ensures s(i+1) mod n.A corollary says that, if there is more than one legitimate state, then units are arranged in a ring, and are enabled to move according to that arrangement. That limits the applicability of the self-stabilization concept to the range of token circulation problems, and concludes the first step.Next I want to modify the Definition 1 in order to extend the number of problems that can be treated using the self-stabilization concept. Coherently with a conservative approach, the impact of the modification should be minimal.I opt to redefine the Minimal States predicate so that it operates set-wise: to this purpose I split l, the set of legitimate states, in a family of subsets L, and for any pair in L I want that “there exists a sequence of moves transferring the system from the one into the other”. The sets in L can be defined either by enumeration, or by a characteristic property. The new formulation of the Minimal States is:DEFINITION 2 (MINIMAL STATES (SET-WISE)). A family L = {l1, …, lk}, with ∪L = l exists such that ∀(la, lb) ∈ L2, la m lbThe last step consists in proving that the new definition widens the applicability of the self-stabilization concept. In Figure 1 I give a simple clock synchronization problem that can be treated with self-stabilization only when this concept is extended with the set-wise minimal states.The problem cannot be treated using Definition 1: the proof is by contradiction, using the only if part of the Theorem, if I want to exploit the presence of redundant paths.The partition I need to apply the set-wise extension is: L = {ticki, tacki | i ∈ [0, 2n - 1]} where ticki = {s | A = 2i - 1 ∧ A = C + 1 ∧ (∀k : Bk = A ∨ Bk = C)} tacki = {s | A = 2i - 1 ∧ A = C - 1 ∧ (∀k : Bk = A ∨ Bk = C)} and the problem is solved by the following self-stabilizing algorithm (the proof is available):A: if (B==B2) and (B2==B3) if even(B1) A=B1+1; else A=B1;C: if (B1==B2) and (B2==B3) if even(B1) C=B1; else C=B1+1;Bk: if A!=(C-1) Bk=A; else Bk=C;

Presents a new architecture for a clock synchronization protocol based on multi-cast communication. The protocol implements the gradual tuning of the clocks, in order to automatically compensate the systematic drift and increase the time between re-synchronizations. Hosts participating in the same service are grouped into a cohort: the protocol self-stabilizes into an optimal routine where all members of a cohort are periodically synchronized with the same messages. New members dynamically joining the cohort perturb this routine, which is spontaneously and eventually restored.

Simple diffusion consists in propagating some data or computation to every unit in a network by spreading it from one unit to its neighbors, which in their turn spread it to the neighbors until every unit is reached. Simple diffusion is easy to implement, scalable, robust with respect to omission faults, and privileges local communication (i.e., uses only links whose cost is the lowest in terms of time needed and/or traffic generated). A solution to the problem of keeping synchronized all the clocks in a large distributed system is presented, that is based on simple diffusion. The traffic generated is O(N), where N is the number of units in the network. The attainable precision is O(d*/spl epsiv/) where /spl epsiv/ is the precision with which a unit can synchronize its clock with that of a neighbor, and d is the maximum distance between a unit and the nearest reference clock.>