Log In Sign Up

Fault Localization in Cloud using Centrality Measures

by   Narayanaa S R, et al.

Fault localization is an imperative method in fault tolerance in a distributed environment that designs a blueprint for continuing the ongoing process even when one or many modules are non-functional. Visualizing a distributed environment as a graph, whose nodes represent faults (fault graph), allows us to introduce probabilistic weights to both edges and nodes that cause the faults. With multiple modules like databases, run-time cloud, etc. making up a distributed environment and extensively, a cloud environment, we aim to address the problem of optimally and accurately performing fault localization in a distributed environment by modifying the Graph optimization approach to localization and centrality, specific to fault graphs.


Fault Localization for Declarative Models in Alloy

Fault localization is a popular research topic and many techniques have ...

Fault and Performance Management in Multi-Cloud Based NFV using Shallow and Deep Predictive Structures

Deployment of Network Function Virtualization (NFV) over multiple clouds...

Localizing Faults in Cloud Systems

By leveraging large clusters of commodity hardware, the Cloud offers gre...

Decentralized Source Localization Using Wireless Sensor Networks from Noisy Data

In this paper, the source (event) localization problem is studied in dec...

Self-healing Dilemmas in Distributed Systems: Fault-correction vs. Fault-tolerance

Large-scale decentralized systems of autonomous agents interacting via a...

1 Introduction

Cloud computing is the on-demand availability and delivery of various computer system resources, cloud storage and computing power, without requiring direct management by the user. Today, large clouds, predominantly have functions distributed over various locations from central servers. Cloud computing delivers three types of computing resources - hardware, software, and software development framework, also known as a platform. Recently, the extensive use of cloud services for hosting enterprise applications is leading to service reliability and availability issues for both service users and providers. Several types of faults may occur in the cloud environment leading to failures and performance degradation [1].

Failures, generally lead to breakdown or shut down of a system. In distributed computing architecture, the notion of failure is characterized by partial failures. A fault may occur in any constituent node, process, or network component of the distributed system. This leads to a partial failure and consequently, the performance of the system degrades until there is a complete breakdown. Fault tolerance in a system is the capability of a system to continue performing its expected function regardless of faults. This way, a fault-tolerant system is expected to be reliable and operate successfully in the case of a failure or breakdown. In case of a fault occurring from any particular node, a fault-tolerant system must be able to identify potentially vulnerable modules in a distributed system to replicate their functionality to prevent complete failure of the system.

State-of-the-art fault localization approaches rely on long training sessions based on simulated faults, which is an expensive practice, since it is hard to inject multiple classes of faults in several machines with different access controls, and iterate this process while the system evolves [2]

. Fault detection using deep learning is also studied in the case of small amount of cloud fault feature data


Centrality measures in a graph are a direct indication of influential nodes and links in the network. In most cases, they show the relative significance of nodes and edges in the system. It is a direct indication of influential nodes and links in the network. Researchers have developed many algorithms for identifying relatively important nodes in a network. The basic and locally computed centrality measure is degree centrality. Other commonly used metrics are betweenness centrality, closeness centrality, PageRank, and HITS eigenvector centrality, which are more relevant in single-layer networks, limiting their applications in multi-layer networking systems

[4]. Among these, PageRank is a popular and frequently used metric, designed for ranking of web pages, it is widely applied in other applications also.

In this paper, we propose a fault localization method that uses centrality measures and works within the constraints of Cloud systems to help us accurately identify important components in the cloud and localize them in case of a breakdown or failure, triggered by itself or another component it depends on.

The contributions of this work are: (i) a novel approach to identify highly important and vulnerable components in cloud environments to localize the fault triggering components (ii) an experimental evaluation of the suggested method for identifying and locating different combinations of faults arising from different modules.

The paper is organized as follows. Section 2 overviews the existing work on fault localization techniques. Section 3 discusses the theoretical background required. Section 4 proposes a centrality measure-based localization method. Section 5 illustrates the experimental results of the approach. Section 6 summarizes the main contribution of the paper and a few future work possible.

2 Related Work

A failure occurs when the user perceives that the software has ceased to deliver the expected result. The user may need to identify the severity of the levels of failures such as catastrophic, critical, major, or minor, depending on their impact on the systems. Omission, Hardware, Software, Network, Response, Virtual Machine (VM), Application failures are various types of failures in Cloud systems. An abnormal condition or defect at the equipment, component or sub-system level which may lead to a failure is termed as a Fault. Omission faults, Aging-related faults like denial of services, Response faults, Software Faults, Timing faults, Transient faults are various types of faults [5]

. The fault localization process is to be undertaken by developers to identify the fault responsible for the failure. To handle the fault that may occur there are different types of techniques of fault tolerance in the literature that is classified into two categories:

2.1 Proactive Techniques

In Proactive Fault Tolerance, the problems are anticipated before they occur and are avoided based on the influence on the task. One of the methods in Proactive Fault Tolerance is preemptive migration, which uses a control system where the tasks are proctored. When a task is found to be vulnerable, it is shifted to another virtual machine instance. The disadvantage of this method is the wait time for calling another virtual machine [6]. Another example of a proactive fault-tolerance method is Proactive Co-ordinated fault tolerance or PCFT. The PCFT approach aims at monitoring a deteriorating physical machine. Given a deteriorating physical machine, the PCFT approach searches for some optimal target physical machines for the virtual machines hosted on the deteriorating physical machine [7].

2.2 Reactive Techniques

Reactive fault tolerance approaches handle the faults after their occurrence. The working of reactive approaches is response-based rather than anticipation. Reactive approaches are usually conservative and need not examine the system behavior. Steps involved in reactive fault tolerance include (a) Replication: this is a technique used to replicate the task on more than one resource, (b) Task re-submission: when the task fails it will run again in either the same node or on a different resource, this increases the time taken for execution over the expected time because of the repetition of task (c) Retry: re-execution of the failed task in the same resource, but it consumes the same execution time as the Task re-submission, (d) Checkpointing or Restart: It takes snapshots at different times during task execution. This allows the task to be re-executed from the last fault-free state [8].

Other methods including the meta-heuristic-based method have also been used for improving fault tolerance methods in cloud systems to enhance their performance and to make the systems robust

[9]. Failure risk based Cloud Classification System reliability and efficiency improvement methods have been developed by combining risk identification with proactive actions [10].

3 Theoretical Background

In this section, we discuss some basic concepts about the types of faults in cloud architecture and centrality measures in a graph.

3.1 Cloud Computing Infrastructure

Cloud computing infrastructure includes the computers, network facilities, storage devices, and other connected components necessary for offering cloud computing resources and services to users as mentioned in Table 1. These hardware components are located within enterprise data centers. These encompass solid-state drives, multi-core servers, and hard disk drives offering stable storage and network devices, such as firewalls, switches, and routers; all on a large scale [11][12].

Various components in a distributed system
Servers The physical machines that act as host machines for one or more virtual machines.
Virtualization Technology that abstracts physical components such as servers, storage, and networking and provides these as logical resources.
Storage In the form of Storage Area Networks (SAN), network-attached storage (NAS), disk drives etc. along with facilities such as archiving and backup.
Network To provide interconnections between physical servers and storage.
Management Various software for configuring, management and monitoring of cloud infrastructure including servers, network, and storage devices.
Security Components that provide integrity, availability, and confidentiality of data and security of information, in general.
Table 1: Table 1: Various components in a distributed system

Many factors could trigger a fault including data corruption, hardware or software or network outage, unreliable clocks, method failure, parity error, head crash, denial of service, disk full, etc. Faults, in general, are classified into the below-mentioned categories:

Network faults:

Since cloud computing resources are accessed over the internet, one of the most important causes of failure in cloud computing is network faults. These faults may occur due to partitions in the network, packet loss or corruption, congestion, failure of the destination node or link, etc.

Physical faults:

Physical faults mainly occur in hardware resources, such as faults in CPUs, in memory, in storage, failure of power etc.

Process faults:

These faults may occur in processes because of resource shortage, bugs in software, incompetent processing capabilities, etc.

Service expiry faults:

If the service time of a resource expires while an application that leased it is using it, it leads to service faults.

Why Perform Fault Localization?

Fault localization is essential to examine the cloud architecture and help developers improve the reliability and safety of information systems. Some of the examples of fault symptoms include unreachable hosts or networks and in most cases, the origin of the path traced by the defect is important to understand the root cause of a fault.

3.2 Centrality Measures

In graph theory and network analysis, indicators of centrality identify the most important vertices and edges within a graph. They are scalar values given to each node or edge in the graph to quantify its importance based on some assumptions. Centrality concepts were originally developed for social network analysis, and many of the terms used to measure centrality reflect their sociological origin. There are a vast number of centrality measures used by analysts. In our approach, we use closeness, eigenvector, and alpha centrality measures.

Closeness Centrality:

In a connected graph, closeness centrality (or closeness) of a node is a measure of centrality in a network, calculated as the reciprocal of the sum of the length of the shortest paths between the node and all other nodes in the graph. Thus, the more central a node is, the closer it is to all other nodes [13].

Eigenvector Centrality:

In graph theory, eigenvector centrality is a measure of the influence of a node in a network where relative scores are assigned to all nodes in the network based on the concept that connections to high-scoring nodes contribute more to the score of the node in question than equal connections to low-scoring nodes. A high eigenvector score denotes that a node is connected to many nodes who themselves have high scores [14].

Alpha Centrality:

In graph theory and social network analysis, alpha centrality is an alias to Katz centrality [15]. It is a measure of the centrality of nodes within a graph. It is an extension of eigenvector centrality where the degree by which the nodes are impacted by the importance of external sources are taken into account.

4 Proposed Model

Any graph-theoretic model relies on a precise establishment of relationships between nodes involved in the graph and require profound understanding of the underlying system behavior [16]. Fault propagation graphs, usually an input to clustering techniques, are common ways to trace the components affected by the failure of a subset of components in a network of nodes [17]. We define a directed fault graph FG(V, E) whose V represents different faults associated with components and E represents whether or not will occurrence of a fault would trigger another fault. The proposed centrality measure-based fault localization method assigns the importance of modules in a given cloud architecture with computed rank values of different faults associated with a component, obtained from the fault graph model generated. Computation is based on iterations over fault nodes with weights on edges and nodes calculated with certain probabilistic values.

We initially consider the list of all the cloud components like Runtime, pod, database, etc., labeled C1, C2, C3, … , Cn that could potentially become faulty. Further, we derive a list of all faults fki, the suffix indicating the ith fault arising from component k. With this established, one-to-many mapping between components and faults associated with the components is made as shown in Figure 4.1. In any given cloud environment, components in the environment can fail due to multiple faults. Subsequently, a fault could trigger a subset of other faults as the cloud could be seen as one connected graph.

Every fault fki

, initially, has an independent probability P

fki of arising regardless of being triggered by any other fault. Identification of a particular fault in a network is carried out using various failure detection methods including signature and anomaly-based IDS [18]. These probabilistic weights are assigned to all faults which are mapped to cloud modules. These weights are based on the nature of the module and other external factors, which by default are uniform for all the faults and can be assigned based on the log of fault data.

We introduce an impact factor value ifv(fki, fmj) that tells how much of an impact the fault fki has on fault fmj where the relationship from fki to fmj

is one-to-one. These values are specific to architectures and they are calculated based on normalized conditional probability values of a pair of faults and the odds of a fault occurring relative to the occurrence of another fault from the log data of faults. These values represent the initial edge weights of the fault graph FG. As mentioned earlier, the nodes of the directed fault graph FG, have values that represent the initial independent probabilities of occurrence of the corresponding fault. Figure 4.2 shows a schematic graph consisting of two distributed components C

1 and C2, fault f1i occurring with independent probability 0.179 and f2j with probability 0.232 are caused by C1 and C2 respectively where ifv(f2j, f1i) = 0.34 is the impact factor value the fault node f2j has on f1i. The influence value is the normalized conditional probability values of the pair f1i and f2j

Figure 1: Figure 4.1 A graphical representation of different modules in a distributed computing model - C1, C2, C3, …, Cn where multiple faults - f11, f12, f21, f22, etc. are caused by the failure or breakdown of modules C1 to Cn
Figure 2: Figure 4.2 A schematic graph consisting of two distributed components C1 and C2 where f1i and f2j are the faults caused by them respectively where ifv(f2j, f1i) is the influence fault node f2j has on f1i

Subsequently, the edge weight of any edge from f1 to f2 with an initial edge weight, impact factor ifv(f1, f2) and the node weight of a node, Pfi, representing the probability of occurrence of the fault it represents, f2, impacted by f1 in the fault graph FG are updated to

where Z representing normalization constant which is added to all the nodes that are involved in a cycle to stop the iteration when updating the node weights is

Different edges in the fault graph have different edge weights which are differentiated using edge thickness as shown in Figure 4.3. It is experimentally seen that the efficiency and the accuracy of the node finding algorithm depend on the accuracy of the probabilistic assumption of each node.

Figure 3: Figure 4.3 A graphical representation of subset of fault node graph with faults of different components connected with probabilistic edge weight denoted by networkX thickness

4.1 Identification of nodes based on centrality measures

Most site reliability engineering teams use monitoring and alerting systems in which a node’s signal value is used to determine the subsequent actions to be taken. The four golden signals in monitoring are traffic, latency, saturation, and errors. In our model, we record the cause and signal values emitted by the components and we set threshold values for the signal values emitted by the cloud components, and whenever the signal values cross the threshold value, with the type of fault recorded, fault propagation graph FP from the original directed fault graph FG, is initialized as shown in Figure 4.4.

Figure 4: Figure 4.4 A schematic graph in which black colored node represents a potential faulty node from which a fault propagation graph is constructed

We run eigenvector-based and closeness-based centrality indices on the fault propagation graph to find the possibly faulty nodes. With the nodes indicating the type of fault with the possibility of occurrence known, we can then find the vulnerable cloud components from the mapping between faults and cloud modules. For every fault node V, the centrality measure values are calculated using the three centrality measures,

where EVR(fn) is the eigenvector based rank for a fault node fn, and L(fj) is the number of nodes that are connected to fj and,

where CR(fn) is the closeness centrality based rank for a fault node fn, calculated for any node fj that fn connects to and d(fn, fj) is the shortest distance between fn and fj.

Different choices of centrality measure rank fault nodes differently. With the important nodes, representing the faults of high importance and high likelihood of occurring ranked and number of nodes to consider for fault localization known, the faults can be mapped back to the components that raise them to know which get an insight of whose replicas are needed [19].

Alpha Centrality on weighted fault network graph begins with the identification of high centrality score nodes using alpha centrality measure where we consider the weighted adjacency matrix AFP of the fault propagation graph generated where the edge weight between any fi and fj, WEi,j, denotes the degree of influence of fi on fj.

With the weighted adjacency matrix for the fault graph FG known, alpha centrality measure values for the nodes representing faults is calculated. Alpha centrality measure for the graph FG is given by,

where CKatz(fi) is the alpha-centrality based rank for a fault node (fi), AFG represents the adjacency matrix of the fault propagation graph, is called attenuation factor that lies within the range [0, 1] and

is the initial weight given to vertex as a way to differentiate vertices using some quality not modelled by adjacencies, which in our case is the probability of occurrence. Rewriting the equation in a vector form, we get,

When = 0, the eigenvector centrality is nullified and all the nodes have the same centrality value . It can also be observed that as value increases, the impact of reduces. We select 0 , where

represents the numerically largest eigenvalue of A

T. In the case of alpha centrality, calculation of node centrality values in weighted networks lets us consider the edge weights which is a direct measure of the degree of influence of a fault on another fault.

5 Experimental Results

We conducted tests with over a hundred simulated faults originating from various cloud modules. With the module-fault mapping established, initial probabilities of fault occurrence for independent faults were taken from the recent datasets [20]. Further, the impact factor mapping between fault nodes was assigned based on the frequency of dependency of one fault triggering module over another. With these values computed and the faulty node from which the fault propagation graph is constructed known, the relative importance of fault nodes are calculated based on the three centrality measures. In a real-time system, this could be input to what requires replication for fault tolerance [19]. Table 2 represents the list of simulated faults considered along with the module they originate from. The results of the computation directly relate to the modules that are more vulnerable than the rest, in an occasion of a fault occurring.

Fault List
Fault Module
log.fault.vm.steps.smf.svc.maintenance VM
log.fault.vm.steps.cpu.generic-sparc.strand VM
log.fault.proxyDeployment.steps.InvalidPattern Proxy
log.fault.runtime.steps.jwt.KeyParsingFailed Runtime
. . .
log.fault.dbauth.steps.QuotaViolation Database
log.fault.runtime.steps.jwt.TokenNotYetValid Runtime
Table 2: Table 2: List of faults and the module they originate from
CentralityThreshold                  0.6                   0.7                   0.8
(a) Closeness
(b) Eigen
(c) Alpha
Figure 5.1 Graphical representation of fault node graphs with 100 faults using networkX
Threshold = 0.6
Threshold = 0.6
Threshold = 0.7
Threshold = 0.8
Figure 5.2 Graphical comparison of Closeness, Eigenvector and Alpha
centrality measures for various threshold values

Vulnerable modules were found from the faults that were most likely to occur based on the centrality rankings for different threshold values. The test was run with 85, 90, 95, 100, 105, 110 faults and vulnerable modules were observed for threshold values of 0.6, 0.7, and 0.8 using the three centrality measures. Figure 5.1 shows the graphical representation of the fault node graph constructed using networkX with 100 faults considered for closeness centrality, eigenvector centrality, and alpha centrality for threshold values of 0.8, 0.7, and 0.6 respectively. It is observed that alpha centrality finds the vulnerable modules for all the considered threshold values more accurately than eigenvector and closeness centrality measures. Figure 5.2 shows the comparison of observations with the three different centrality measures for threshold values 0.6, 0.7, and 0.8 respectively, against the ideal values. This high accuracy observed in alpha centrality can be explained by the attribution given to the edge weight calculated with the degree of impact the failure of one node has on the other. It is also observed that the closeness centrality measure produces the highest number of false-positive faults among the three considered centrality measures. Since the efficiency with which the faults propagate is less relevant in finding the vulnerable fault modules, a high number of false-positive cases are observed in closeness centrality measure. The accuracy values recorded for the considered faults using alpha, eigenvector, and closeness centrality measures for threshold values 0.6, 0.7, and 0.8 are shown in Table 3.

Centrality/Threshold 0.6 0.7 0.8
Alpha 96.37 93.8 93.17
Eigenvector 88.89 65.3 60.3
Closeness 76.69 61.51 42.32
Table 3: Accuracy for alpha, eigenvector and closeness centrality measures for threshold values 0.6, 0.7 and 0.8

For the simulated faults considered, it is also observed that the accuracy dropping with the threshold value increasing as the number of potential faulty nodes decreases.

Research Questions

In this paper, we address two questions that help in identifying faults in a distributed environment:

Q1. Does the choice of centrality index affect the accuracy of identifying the subset of potential faulty nodes for fault localization?

As discussed, we have implemented three centrality-based indices used in fault localization, namely closeness, eigenvector, and alpha centrality measures. It is interesting to observe that alpha-centrality performs better for various threshold values than eigenvector and closeness centrality measures. Using alpha centrality, the calculation of node centrality values in weighted networks lets us consider the edge weights, a direct measure of the degree of influence of a fault on another fault. This results in better accuracy since the computation of centrality values is fault-specific and not cloud module-specific. It was alarming to observe that the closeness centrality measure produces the highest number of false-positive faults among the three considered centrality measures.

Q2. In the graph model, how does the representation of faults as nodes improve the accuracy when compared to the representation of components as nodes?

Even though having faults representing the vertices increases the complexity of the overall computation significantly due to one-to-many mapping between components and their faults, having a fault propagation-based graph reduces the number of false-positive cases as different faults in a component have different effects on other components. Faults representing nodes make the centrality calculation more specific to a fault, and hence we get a more accurate subset of potentially faulty nodes. This approach ensures both higher accuracy in choosing other modules when one faulty node is observed as well as prevents the selection of components with lesser probabilities of failing thus reducing the number of false-positive cases.

6 Future Work

The cloud archetype has become more practical than ever and has been adopted by researchers, the IT industry, and other organizations. Fault-tolerance approaches are expected to improve services in the cloud environment. However, reliability issues of the cloud workflows have not been extensively considered in the existing approaches and evaluation has been done using some basic metrics, such as response time, availability, and throughput. Many studies model the system behaviour that includes execution paths and component interactions. A more complex, but interesting variant of this research work includes link failure between cloud components and fault tolerance of the same as well as employing more precise methods to compute values in the centrality measure. Deep Learning approaches incorporated with centrality measures may be studied to predict fault-tolerance when the volume of the data increases.

7 Conclusion

This research work has implemented centrality measure-based fault localization techniques to locate faults in distributed systems with a probabilistic method. In our experiments, we conducted tests using the suggested method with simulated faults in a distributed computing environment. The choice of centrality index impacts the precision of fault localization. The results of these experiments with eigenvector, closeness, and alpha centrality measures were analyzed. Among the three measures, it is observed that the identification of vulnerable cloud components has the highest accuracy with alpha-centrality measure and the least with closeness centrality measure and this sets a reliable way to prioritize vulnerable cloud endpoints and modules in an event of a fault occurring to make the architecture more robust.


  • [1] S. Prathiba and S. Sowvarnica, “Survey of failures and fault tolerance in cloud,” Int. Conf. Comput. Commun. Technol. (ICCCT), pp. 169–172, 2017.
  • [2] S. M. A. Ataallah, S. M. Nassar, and E. E. Hemayed, “Fault tolerance in cloud computing - survey,” 11th Int. Comput. Eng. Conf. (ICENCO), pp. 241–245, 2015.
  • [3] W. Gao and Y. Zhu, “A cloud computing fault detection method based on deep learning,” Comput. Commun., vol. 05, pp. 24–34, 2017.
  • [4] S. Kamath and M. S., “Graph energy based centrality measure to identify influential nodes in social networks,” IEEE 5th International Conference for Convergence in Technology (I2CT), pp. 1–6, 2019.
  • [5] M. Hasan and M. S. Goraya, “Fault tolerance in cloud computing environment: A systematic survey,” Comput Ind, vol. 99, pp. 156–172, 2018.
  • [6] M. B. K. Ghamdan Mohammed Qasem, “Proactive fault tolerance for resilience cloud data centers to improve performance efficiency,” Int. J. Eng. Res. Technol. (IJERT) NCRIT - 2016, vol. 4, 2016.
  • [7] J. Liu, S. Wang, A. Zhou, S. Kumar, F. Yang, and R. Buyya, “Using proactive fault-tolerance approach to enhance cloud service reliability,” IEEE Trans. on Cloud Comput., vol. 6, pp. 1191–1202, 2018.
  • [8] E. AbdElfattah, M. Elkawkagy, and A. El-Sisi, “A reactive fault tolerance approach for cloud computing,” 13th Int. Comput. Eng. Conf. (ICENCO), pp. 190–194, 2017.
  • [9] P. Kumari and P. Kaur, “A survey of fault tolerance in cloud computing,” J King Saud Univ. - Comput. Inf. Sci., 2018.
  • [10] Y. Tian, J. Tian, and N. Li, “Cloud reliability and efficiency improvement via failure risk based proactive actions,” J Syst Softw, vol. 163, p. 110524, 2020.
  • [11] M. Steinder and A. Sethi, “A survey of fault localization techniques in computer networks,” Sci. Comput. Program., vol. 53, pp. 165–194, 2004.
  • [12] A. Dusia and A. S. Sethi, “Recent advances in fault localization in computer networks,” IEEE Commun. Surv. Tutor., vol. 18, no. 4, pp. 3030–3051, 2016.
  • [13] E. Cohen, D. Delling, T. Pajor, and R. F. Werneck, “Computing classic closeness centrality, at scale,” Proceedings of the Second ACM Conference on Online Social Networks, p. 37–50, 2014.
  • [14] A. B. M. K. Pandia, “Eigenvector centrality and its application in research professionals’ relationship network,” International Conference on Futuristic Trends on Computational Analysis and Knowledge Management (ABLAZE), pp. 510–514, 2015.
  • [15] Y. Zhang, Y. Bao, S. Zhao, J. Chen, and J. Tang, “Identifying node importance by combining betweenness centrality and katz centrality,” Int. Conf. Cloud Comput. Big Data (CCBD) 2015, pp. 354–357, 2015.
  • [16] A. Dusia and A. Sethi, “Recent advances in fault localization in computer networks,” IEEE Communications Surveys & Tutorials, vol. 18, pp. 3030 – 3051, 05 2016.
  • [17] S. Prathiba, S. Sowvarnica, B. Latha, and G. Sumathi, “A comparative study of task and fault tolerance clustering techniques for scientific workflow applications in cloud platform,” in Data Science Analytics and Applications (S. R and M. Sharma, eds.), pp. 1–7, Springer Singapore, 2018.
  • [18] M. Smara, M. Aliouat, A.-S. K. Pathan, and Z. Aliouat, “Acceptance test for fault detection in component-based cloud computing and systems,” Future Gener Comput Syst, vol. 70, pp. 74–93, 2017.
  • [19] M. R. Mesbahi, A. M. Rahmani, and M. Hosseinzadeh, “Reliability and high availability in cloud computing environments: A reference roadmap,” Hum.-Centric Comput. Inf. Sci., vol. 8, no. 1, 2018.
  • [20] L. Mariani, C. Monni, M. Pezzé, O. Riganelli, and R. Xin, “Localizing faults in cloud systems,” Proc. - 11th IEEE Int. Conf. Softw. Test. Verif. Valid. ICST, pp. 262–273, 2018.