Methods, devices, and processors for identifying service failure propagation paths in cloud computing environments

Abstract

This invention discloses a method, apparatus, and processor for identifying service failure propagation paths in a cloud computing environment. The method includes extracting service runtime call data from a target dataset; establishing a service interaction graph based on the service runtime call data; traversing the service interaction graph to establish a service relationship graph; and outputting a set of service failure propagation paths based on the service relationship graph and the probability of service failure. This invention, through comprehensive analysis of service runtime data and service environment data, demonstrates good effectiveness in determining faulty services and the probability of service failure. Furthermore, by analyzing actual service calls in a cloud computing environment and establishing a service relationship graph model based on a dynamically changing service interaction graph model, this invention simplifies the structure and improves the effectiveness of determining service failure propagation paths.

Description

Technical Field

[0001] This invention relates to a method, apparatus, and processor for identifying service failure propagation paths in a cloud computing environment, belonging to the field of service failure propagation impact analysis under cloud computing. Background Technology

[0002] The complexity, dynamism, and openness of cloud computing environments have led to increasingly complex scales and structures in distributed software systems, and system failures have exhibited characteristics ranging from simple to complex, from static to dynamic, and from deterministic to uncertain. To better detect and prevent service failures and reduce their propagation impact, it is necessary to construct service relationship graph models based on the actual operation of services and use service failure propagation path discrimination for auxiliary analysis. Youngjung Geum et al. proposed a method and effect analysis for service failure identification and assessment of potential failures, combining service characteristics with traditional failure mode and impact analysis and using grey relational analysis. However, this method has certain limitations and cannot well adapt to large-scale complex models. Cui Pengshuai et al. proposed a hierarchical model for service failure propagation and designed a service hierarchical algorithm, determining the maximum probability failure set based on prior probabilities and Bayesian principles, and finally performing failure analysis. However, Cui Pengshuai et al. did not consider the current operating state of the service and the current environmental state of the service. He Jialang et al. proposed a software program fault location method based on fault propagation perception. This method only collects program coverage paths and uses the different frequencies of program nodes appearing in normal and faulty paths to determine the suspiciousness of program nodes in the suspicious space for fault propagation analysis. However, this method uses only a single data type for fault propagation analysis, which leads to the lack of factors related to fault propagation and limits the accuracy of the results. Li Guo et al. established a fault propagation model based on small-world clustering characteristics. Starting from the inherent network topology of complex systems, they studied the fault propagation mechanism. By combining the intensity of fault propagation, they described the fault propagation process according to the principle of step-by-step diffusion. They used the ant colony algorithm to obtain the fault propagation path with the strongest diffusion ability and the corresponding key nodes. However, this method is not applicable to dynamically changing system structures because it is designed for inherent system structures.

[0003] Most existing studies only consider relatively single data types and specific software systems. How to determine the service failure propagation path in a cloud computing environment by comprehensively considering service operation data and environmental data, as well as the strength and dynamic changes of service call relationships, has become an urgent problem to be solved. Summary of the Invention

[0004] This invention provides a method, apparatus, and processor for determining service failure propagation paths in a cloud computing environment, for obtaining service failure propagation paths.

[0005] The technical solution of this invention is: a method for determining service failure propagation paths in a cloud computing environment, comprising: extracting service operation status call data from a target dataset; establishing a service interaction graph based on the service operation status call data; traversing the service interaction graph to establish a service relationship graph; and outputting a set of service failure propagation paths based on the service relationship graph and the probability of service failure.

[0006] Optionally, the step of extracting service running status call data from the target dataset includes: reading the target dataset monitored in the cloud environment, extracting service call data from the target dataset, filtering the service call data, and obtaining service call data that is currently running, as the service running status call data.

[0007] Optionally, the step of establishing a service interaction graph based on service operation status call data includes: obtaining the service user name, service call number, service call status, and service name based on the service operation status call data, establishing a service interaction graph represented by an adjacency list, and monitoring new service call data in real time for updating the service interaction graph.

[0008] Optionally, the step of traversing the service interaction graph and establishing a service relationship graph includes: traversing the service interaction graph, counting the number of interaction connections with the same "service user name, service name" in the service interaction graph as the frequency of the same service call, and establishing a service relationship graph represented by an adjacency list based on the service user name, service name, and the frequency of the same service call; wherein, if the service call status with the same "service user name, service name" is in the running state, the frequency is incremented by 1, otherwise it is incremented by 0.

[0009] Optionally, the step of outputting a set of service failure propagation paths based on the service relationship graph and the probability of service failure includes:

[0010] Based on the service relationship graph, the system reads the names of all currently running services. It then uses historical normal data (including service operation and service environment data), randomly selected samples from this historical normal data, and currently monitored data (including service operation and service environment data) obtained from the service names to calculate the probability of failure for each service name using hypothesis testing. This probability is compared with a set threshold to determine the faulty service name. The system also records other service names and their corresponding service probabilities. Based on the read faulty service name, other service names, and their probabilities, the system calculates the pairwise similarity between the faulty service and other services based on the service relationship graph. The system then calculates the service failure propagation probability using the similarity scores. Finally, it searches for service failure propagation paths using the service relationship graph, service failure propagation probabilities, and service failure propagation probability thresholds, outputting a set of service failure propagation paths.

[0011] Optionally, the step of outputting a set of service failure propagation paths based on the service relationship graph and the probability of service failure is as follows:

[0012] Step 5.1: Read the list of service relationship diagrams (ServiceRelationship), the list of faulty service names (BreakService), the list of service failure probabilities (ServiceExcept), and the list of other service names (OtherService). Then execute Step 5.2.

[0013] Step 5.2: Initialize the empty list Path to store the service failure propagation path, initialize the temporary variable w = 0, initialize the temporary variable m = 0, and execute Step 5.3;

[0014] Step 5.3: Determine if w is less than the length of the list BreakService. If the condition is true, proceed to Step 5.4; otherwise, proceed to Step 5.45.

[0015] Step 5.4: Initialize an empty list Correlation to store the similarity between services, then proceed to Step 5.5;

[0016] Step 5.5: Determine if m is less than the length of the OtherService list. If the condition is true, proceed to Step 5.6; otherwise, proceed to Step 5.9.

[0017] Step 5.6: Perform pruning operations on ServiceRelationship, then proceed to Step 5.7. Pruning involves retaining only service relationships that are currently running.

[0018] Step 5.7: Add the service similarity between the service name corresponding to the service name with index w in the BreakService record calculated by the WSimRank algorithm and the service name corresponding to the service name with index m in the OtherService record, and then proceed to Step 5.8.

[0019] Step 5.8, m++, then execute Step 5.9;

[0020] Step 5.9: Initialize an empty list Propagation to store the calculated service failure propagation probability, initialize the temporary variable u = 0, and execute Step 5.10;

[0021] Step 5.10: Is u less than the length of the OtherService list? If the condition is true, proceed to Step 5.11; otherwise, proceed to Step 5.13.

[0022] Step 5.11: Add the list Correlation to the list Propagation, record the data with index u, and the list ServiceExcept to record the failure probability of the service with index u. Then proceed to Step 5.12.

[0023] Step 5.12, u++, execute Step 5.10;

[0024] Step 5.13: Initialize the service failure propagation probability threshold Pthreshold, initialize the list PathInterim to store temporary paths, add the list BreakService to the list PathInterim to record data with index w, and execute Step 5.14.

[0025] Step 5.14: Initialize the temporary variable v = 0, initialize the list Part1, execute Part1.addAll(PathInterim) on Part1, and execute Step 5.15; where Part1.addAll(PathInterim) means that Part1 overwrites and adds the list PathInterim.

[0026] Step 5.15: Determine if v is less than the length of list Part1. If the condition is true, proceed to Step 5.16; otherwise, proceed to Step 5.27.

[0027] Step 5.16: Initialize temporary variable n = 0, initialize temporary variable z = 0, initialize list OutNode to store the name of the running successor node service of the last node on the path with index v obtained by ServiceRelationship, and execute Step 5.17.

[0028] Step 5.17: Determine if n is less than the length of the list OutNode. If the condition is true, proceed to Step 5.18; otherwise, proceed to Step 5.26.

[0029] Step 5.18: Initialize the variable Pvalue to store the service failure propagation probability corresponding to the service name with index n obtained using Propagation in the OutNode record. Then execute Step 5.19.

[0030] Step 5.19: Determine if Pvalue is greater than Pthreshold. If the condition is true, proceed to Step 5.20; otherwise, proceed to Step 5.25.

[0031] Step 5.20: Does the path with index v recorded by PathInterim contain the service name with index n recorded by OutNode? If the condition is not met, proceed to Step 5.21; otherwise, proceed to Step 5.25.

[0032] Step 5.21: Determine if z equals 0. If the condition is true, proceed to Step 5.22; otherwise, proceed to Step 5.24.

[0033] Step 5.22: Replace the path with index v in the PathInterim record with the path with index v in the PathInterim record +">" + Pvalue + the service name with index n in the OutNode record, and then execute Step 5.23.

[0034] Step 5.23, z++, then execute Step 5.25;

[0035] Step 5.24: Add the path with index v in PathInterim, then add the service name with index n in OutNode, and execute Step 5.23.

[0036] Step 5.25, n++, then execute Step 5.17;

[0037] Step 5.26, v++, execute Step 5.15;

[0038] Step 5.27: Check if Part 1 equals PathInterim. If the condition is true, proceed to Step 5.28; otherwise, proceed to Step 5.14.

[0039] Step 5.28: Add PathInterim to Path, initialize the list PathTerm to store temporary paths, add BreakService to PathTerm to record the service name with index w, and execute Step 5.29;

[0040] Step 5.29: Initialize temporary variable s = 0, initialize list Path2, execute Part2..addAll(PathTerm) on Part2, and execute Step 5.30, where Path2.addAll(PathTerm) means adding list PathTerm to the list.

[0041] Step 5.30: Is s less than the length of list Path2? If the condition is true, execute Step 5.31; otherwise, execute Step 5.42.

[0042] Step 5.31: Initialize temporary variable g = 0, initialize temporary variable f = 0, initialize list InNode to store the name of the running predecessor node service of the last node on the path with index s obtained by ServiceRelationship, and execute Step 5.32.

[0043] Step 5.32: Determine if g is less than the length of the list InNode. If the condition is true, execute Step 5.33; otherwise, execute Step 5.41.

[0044] Step 5.33: Initialize the variable Qvalue to store the service failure propagation probability corresponding to the service name with index g of the InNode record obtained using Propagation, and then execute Step 5.34.

[0045] Step 5.34: Is Qvalue greater than Pthreshold? If the condition is true, proceed to Step 5.35; otherwise, proceed to Step 5.40.

[0046] Step 5.35: Does PathTerm.get(s) exist? If not, proceed to Step 5.36; otherwise, proceed to Step 5.40. Here, PathTerm.get(s) represents the path with index s recorded in PathTerm, and InNode.get(g) represents the service name with index g recorded in InNode.

[0047] Step 5.36: Check if f equals 0. If the condition is true, proceed to Step 5.37; otherwise, proceed to Step 5.39.

[0048] Step 5.37: Add the path with index 's' to the PathTerm record, then add "<" to the Qvalue record and the service name with index 'g' to the InNode record. Then execute Step 5.38.

[0049] Step 5.38, f++, then execute Step 5.40;

[0050] Step 5.39: Add a PathTerm record with index 's' followed by the path name, "<", Qvalue, and InNode record with index 'g'. Then execute Step 5.38.

[0051] Step 5.40, g++, execute Step 5.32;

[0052] Step 5.41, s++, execute Step 5.30;

[0053] Step 5.42: Is Part 2 equal to PathTerm? If the condition is true, proceed to Step 5.43; otherwise, proceed to Step 5.29.

[0054] Step 5.43: Add PathTerm to Path, then execute Step 5.44;

[0055] Step 5.44, w++, execute Step 5.3;

[0056] Step 5.45: Output the list Path and end the execution.

[0057] Optionally, the WSimRank algorithm is specifically as follows:

[0058]

[0059] S(I i (V t ),I j (V b ))=W(I i (V t →V t )·W(I j (V b →V b )·WSimRank(I i (V t ),(I j (Vb ))

[0060]

[0061]

[0062] Among them, WSimRank(V t V b ) represents V t V b Service similarity, V t V b Let t and b represent services respectively, C be the loss coefficient, and S(I) be the loss coefficient. i (V t ),I j (V b )) indicates I i (V t ), I j (V b The product of service similarity and weight, |I(V) t | represents the total number of neighboring nodes of service t, |I(V) b | represents the total number of neighboring nodes of service b, I i (V t ) represents the i-th neighbor node of service t, I j (V b W(I) represents the j-th neighbor node of service b; i (V t →V t W(I) represents the standardized weight between the i-th neighbor node of service t and service t. j (V b →V b ) represents the standardized weight of the j-th neighbor node of service b relative to service b, WSimRank(I i (V t ),(I j (V b )) indicates I i (V t ), I j (V b Service similarity, w(I) i (V t →V t () represents the weight between the i-th neighbor node of service t and service t. Let represent the sum of the weights of the i neighboring nodes of service t and service t; This represents the number of interactions between the i-th neighbor node of service t and service t in the service relationship graph. This represents the number of times the i-th neighbor node of service t is run in the service relationship graph. K represents the number of times service t runs in the service relationship graph. Graph This represents the total number of runs contained in the service relationship diagram; service t represents the service with service name t in the service relationship diagram, and service b represents the service with service name b in the service relationship diagram.

[0063] According to another aspect of the present invention, a service failure propagation path discrimination device in a cloud computing environment is also provided, comprising: an extraction module for extracting service operation status call data from a target dataset; a first establishment module for establishing a service interaction graph based on the service operation status call data; a second establishment module for traversing the service interaction graph to establish a service relationship graph; and an output module for outputting a set of service failure propagation paths based on the service relationship graph and the failure probability of the service.

[0064] According to another aspect of the present invention, a processor is also provided, the processor being configured to perform the method described in any one of the above embodiments.

[0065] According to another aspect of the present invention, a computer-readable storage medium is also provided, the computer-readable storage medium including a stored program that, when executed by a processor, causes the processor to implement the method described in any one of the above embodiments.

[0066] The beneficial effects of this invention are as follows: By comprehensively analyzing service operation data and service environment data, this invention has a good effect on determining the probability of service and computing service failures; by analyzing the actual service call situation in the cloud computing environment, this invention establishes a service relationship graph model based on a dynamically changing service interaction graph model, which simplifies the structure and improves the effectiveness of determining the service failure propagation path; when a service failure occurs, the impact of the failure can be judged, and the service failure propagation path can be obtained according to the failure propagation trend, which can effectively assist relevant personnel to handle the situation in a timely manner, avoid the failure propagation causing more services to fail, causing batch service failures, and affecting the normal operation of the system. Attached Figure Description

[0067] Figure 1 This is the overall flowchart of the present invention;

[0068] Figure 2 for Figure 1 The specific process of Step 1 in the middle;

[0069] Figure 3 for Figure 1 Part 1: Detailed process of Step 2;

[0070] Figure 4 for Figure 1Part Two: Detailed Process of Step 2;

[0071] Figure 5 for Figure 1 The specific process of Step 2 is described in Part Three;

[0072] Figure 6 for Figure 1 The specific process of Step 3;

[0073] Figure 7 for Figure 1 Part 1: Detailed process of Step 4;

[0074] Figure 8 for Figure 1 Part Two: Detailed Process of Step 4;

[0075] Figure 9 for Figure 1 Part 1: Detailed process of Step 5;

[0076] Figure 10 for Figure 1 Part Two: Detailed Process of Step 5;

[0077] Figure 11 for Figure 1 The specific process of Step 5 is part three;

[0078] Figure 12 Establish a service interaction graph for the implementation example;

[0079] Figure 13 Establish a service relationship graph for the implementation example. Detailed Implementation

[0080] The invention will be further described below with reference to the accompanying drawings and embodiments, but the scope of the invention is not limited to the description.

[0081] Example 1: As Figure 1-13 As shown, a method for determining service failure propagation paths in a cloud computing environment includes: extracting service operation status call data from a target dataset; establishing a service interaction graph based on the service operation status call data; traversing the service interaction graph to establish a service relationship graph; and outputting a set of service failure propagation paths based on the service relationship graph and the probability of service failure.

[0082] Optionally, the step of extracting service running status call data from the target dataset includes: reading the target dataset monitored in the cloud environment, extracting service call data from the target dataset, filtering the service call data, and obtaining service call data that is currently running, as the service running status call data.

[0083] Optionally, the step of establishing a service interaction graph based on service operation status call data includes: obtaining the service user name, service call number, service call status, and service name based on the service operation status call data, establishing a service interaction graph represented by an adjacency list, and monitoring new service call data in real time for updating the service interaction graph.

[0084] Optionally, the step of traversing the service interaction graph and establishing a service relationship graph includes: traversing the service interaction graph, counting the number of interaction connections with the same "service user name, service name" in the service interaction graph as the frequency of the same service call, and establishing a service relationship graph represented by an adjacency list based on the service user name, service name, and the frequency of the same service call; wherein, if the service call status with the same "service user name, service name" is in the running state, the frequency is incremented by 1, otherwise it is incremented by 0.

[0085] Optionally, the step of outputting a set of service failure propagation paths based on the service relationship graph and the failure probability of services includes: reading the names of each running service based on the service relationship graph; calculating the failure probability of the service represented by each service name using hypothesis testing, and comparing it with a set threshold to determine the faulty service name; recording other service names and the failure probability of the services represented by those service names; calculating the pairwise similarity between the faulty service and other services based on the service relationship graph, using the similarity to calculate the service failure propagation probability; searching for service failure propagation paths through the service relationship graph, the service failure propagation probability, and the service failure propagation probability threshold, and outputting a set of service failure propagation paths.

[0086] Furthermore, the present invention provides a service failure propagation path discrimination device in a cloud computing environment, comprising: an extraction module for extracting service operation status call data from a target dataset; a first establishment module for establishing a service interaction graph based on the service operation status call data; a second establishment module for traversing the service interaction graph to establish a service relationship graph; and an output module for outputting a set of service failure propagation paths based on the service relationship graph and the failure probability of the service.

[0087] Furthermore, the present invention provides a processor configured to perform any of the methods described above.

[0088] Furthermore, the present invention provides a computer-readable storage medium comprising a stored program that, when executed by a processor, causes the processor to implement the service failure propagation path discrimination method in a cloud computing environment as described above.

[0089] Furthermore, the specific steps for extracting service runtime status call data from the target dataset can be as follows:

[0090] Step 1.1: Read the service call dataset D monitored in the cloud environment, extract the service call data from the service call dataset D, separate the attributes of the service call data with colons, store it in the initialization list ServiceDataList, initialize the temporary variable i = 0, and execute Step 1.2; The attributes of the service call data include service call number, service user name, service name, and service call status;

[0091] Step 1.2: Initialize the variable ServiceStatus = "Working" and initialize an empty list TransferList. This list will store service running status call data. Then proceed to Step 1.3.

[0092] Step 1.3: Determine if i is less than the length of the list ServiceDataList. If the condition is true, proceed to Step 1.4; otherwise, proceed to Step 2.

[0093] Step 1.4: Initialize the variable ServiceRunStatus to store the service call status obtained from the data at index i in the ServiceDataList. Then execute Step 1.5.

[0094] Step 1.5: Determine if ServiceRunStatus is equal to ServiceStatus1. If the condition is true, proceed to Step 1.6; otherwise, proceed to Step 1.7.

[0095] Step 1.6: Add the data with index i to the ServiceDataList in the TransferList, then proceed to Step 1.7;

[0096] Step 1.7, i++, execute Step 1.3.

[0097] Furthermore, the steps for establishing the service interaction graph based on the service operation status call data are as follows:

[0098] Step 2.1: Read the list TransferList, initialize an empty list ServiceInteractive to store the service interaction graph, and initialize the temporary variable j = 0;

[0099] Step 2.2: Is j less than the length of the list TransferList? If the condition is true, proceed to Step 2.3; otherwise, proceed to Step 2.11.

[0100] Step 2.3: Use the list TransferList to record the data at index j, obtain the service user name and store it in the initialization variable SerUser, obtain the service name and store it in the initialization variable SerPro, obtain the service call status and store it in the initialization variable SerStatus, obtain the service call number and store it in the initialization variable CallId, initialize the temporary variable h = 0, and execute Step 2.4.

[0101] Step 2.4: Determine if h is less than the length of the ServiceInteractive list. If the condition is true, proceed to Step 2.5; otherwise, proceed to Step 2.10.

[0102] Step 2.5: Initialize the String type variable ServiceUser1 to store the service user name obtained by using the data at index h of the ServiceInteractive list, and then proceed to Step 2.6.

[0103] Step 2.6: Determine if ServiceUser1 is equal to SerUser. If the condition is true, proceed to Step 2.7; otherwise, proceed to Step 2.9.

[0104] Step 2.7: Replace the data at index h of the ServiceInteractive record in the list with the data at index h of the ServiceInteractive record in the list + CallId + "-" + SerStatus + "("SerPro + ")", then execute Step 2.8;

[0105] Step 2.8, j++, execute Step 2.2;

[0106] Step 2.9, h++, execute Step 2.4;

[0107] Step 2.10: Add SerUser+“:”CallId+“-”SerStatus+“(”SerPro+“)” to the ServiceInteractive list, then execute Step 2.8;

[0108] Step 2.11: Monitor new service call data in real time, obtain the service user name and store it in the initialization variable ServiceUser, obtain the service name and store it in the initialization variable ServicerPro, obtain the service call status and store it in the initialization variable ServiceStatus, obtain the call number and store it in the initialization variable ServiceCallId, initialize the temporary variable p=0, and execute Step 2.12.

[0109] Step 2.12: Read the list of ServiceInteractive that stores service interaction graphs, and then execute Step 2.13;

[0110] Step 2.13: Check if ServiceStatus equals "Working". If the condition is true, proceed to Step 2.14; otherwise, proceed to Step 2.20.

[0111] Step 2.14: Is p less than the length of the list ServiceInteractive? If the condition is true, proceed to Step 2.15; otherwise, proceed to Step 2.19.

[0112] Step 2.15: Initialize the String type variable ServerUser to store the service user name obtained by using the data at index p of the ServiceInteractive list, and then execute Step 2.16;

[0113] Step 2.16: Determine if ServerUser is equal to ServiceUser. If the condition is true, proceed to Step 2.17; otherwise, proceed to Step 2.18.

[0114] Step 2.17: Replace the data at index p of the ServiceInteractive record in the list with the data at index p of the ServiceInteractive record in the list + ServiceCallId + "-" ServiceStatus + "(" + ServicePro + ")"), then execute Step 3;

[0115] Step 2.18, p++, execute Step 2.14;

[0116] Step2.19, ServiceInteractive adds ServiceUser+":"+ServiceCallId+":"+ServiceStatus+"("+ServicePro+")" and execute Step3;

[0117] Step 2.20: Determine if p is less than the length of the list ServiceInteractive. If the condition is true, proceed to Step 2.21; otherwise, proceed to Step 2.29.

[0118] Step 2.21: Initialize the list ServerCallId to store the service call number obtained using the data with index p recorded by ServiceInteractive; initialize the String type variable Seruser to store the service user name obtained using the data with index p recorded by ServiceInteractive; initialize the temporary variable q = 0; and execute Step 2.22.

[0119] Step 2.22: Determine if Seruser is equal to ServiceUser. If the condition is true, proceed to Step 2.23; otherwise, proceed to Step 2.28.

[0120] Step 2.23: Determine if q is less than the length of the list ServerCallId. If the condition is true, proceed to Step 2.24; otherwise, proceed to Step 2.27.

[0121] Step 2.24: Check if the data with index q in the ServerCallId list is equal to ServiceCallId. If the condition is true, proceed to Step 2.25; otherwise, proceed to Step 2.26.

[0122] Step 2.25: Use the current service call data obtained from ServiceUser, ServicePro, ServiceStatus, and ServiceCallId to update ServiceInteractive, then proceed to Step 3;

[0123] Step 2.26, q++, execute Step 2.23;

[0124] Step 2.27: Replace the data at index p of the ServiceInteractive record in the list with the data at index p of the ServiceInteractive record in the list + ServiceCallId + "-" ServiceStatus + "(" + ServicePro + ")"), then execute Step 3;

[0125] Step 2.28, p++, execute Step 2.20;

[0126] Step 2.29: Add ServiceUser+“:”+ServiceCallId+“-”+ServiceStatus+“(”+ServicePro+“)” to the ServiceInteractive list, and then execute Step 3.

[0127] Furthermore, the specific steps for traversing the service interaction graph and establishing the service relationship graph are as follows:

[0128] Step 3.1: Read the Service Interaction Graph list ServiceInteractive, then execute Step 3.2;

[0129] Step 3.2: Initialize an empty list ServiceRelationship to store the service relationship graph, initialize the temporary variable x = 0, and then execute Step 3.3;

[0130] Step 3.3: Determine if x is less than the length of the ServiceInteractive list. If the condition is true, proceed to Step 3.4; otherwise, proceed to Step 4.

[0131] Step 3.4: Use the list ServiceInteractive to record the data at index x, obtain the service name and store it in the initialization list ServiceProvide, obtain the service user name and store it in the initialization variable ServiceUser, obtain the service call status and store it in the initialization list ServiceStatus, remove duplicates from the list ServiceProvide and store them in the initialization list Ser, initialize the temporary variable y = 0, initialize the temporary variable z = 0, and execute Step 3.5.

[0132] Step 3.5: Determine if y is less than the length of list Ser. If the condition is true, proceed to Step 3.6; otherwise, proceed to Step 3.13.

[0133] Step 3.6: Initialize ServiceFrequency to store the frequency of calls to the same service. ServiceFrequency = 0, SerRelationship = ServiceUser + ":" to store service relationships. Then proceed to Step 3.7.

[0134] Step 3.7: Is z less than the length of the ServiceProvide list? If the condition is true, proceed to Step 3.8; otherwise, proceed to Step 3.11.

[0135] Step 3.8: Check if the data at index y of the Ser record in the list is equal to the data at index z of the ServiceProvide record in the list, and check if the data at index z of the ServiceStatus record is equal to "Working". If the conditions are true, proceed to Step 3.9; otherwise, proceed to Step 3.10.

[0136] Step 3.9, ServiceFrequency++, then proceed to Step 3.10;

[0137] Step 3.10, z++, then execute Step 3.7;

[0138] Step 3.11: SerRelationship = SerRelationship + ServiceFrequency "(" + data of index y in list Ser + ")", then execute Step 3.12;

[0139] Step 3.12, y++, then execute Step 3.5;

[0140] Step 3.13: Add SerRelationship to the ServiceRelationship list, then proceed to Step 3.14;

[0141] Step 3.14, x++, execute Step 3.3.

[0142] Furthermore, based on the service relationship diagram, the probability of service failure can be determined. The specific steps are as follows:

[0143] Step 4.1: Read the ServiceRelationship list containing the service relationship diagram, and then proceed to Step 4.2;

[0144] Step 4.2: Initialize the RunService list to store the names of services currently in operation obtained using ServiceRelationship; initialize the empty ServiceExcept list to store the names of other services besides the faulty service names and the probability of failure of the service represented by each service name; initialize the empty OtherService list to store the names of other services besides the faulty service names; initialize the empty BreakService list to store the faulty service names; initialize the temporary variable a = 0; and execute Step 4.3.

[0145] Step 4.3: Determine if 'a' is less than the length of the RunService list. If the condition is true, proceed to Step 4.4; otherwise, proceed to Step 5.

[0146] Step 4.4: Initialize an empty two-dimensional list NormDataList r*c This is used to store the sample data for the RunService record with index 'a'. An empty list `ColumnList` is initialized to store the column names, and an empty list `PnormList` is initialized to store the sample hypothesis test probability values ​​for the RunService record with index 'a'. A temporary variable `g` is initialized to 0, and Step 4.5 is executed. (The `NormDataList` is used for this purpose.) r*c =[[J1],[J2],[J3],...,[J r [J1] = [M1, M2, M3, ..., M c J1 is the first item containing data about service operation and service environment. r For the r-th entry containing data about service operation and service environment, M c Let r be the c-th attribute of the first data item containing service operation and service environment data, r be the total number of data items in the list containing service operation and service environment data, and c be the total number of attributes for each data item.

[0147] Step 4.5: Input the historical service running dataset A corresponding to the service name when the RunService record index is 'a', and execute Step 4.6;

[0148] Step 4.6: Input the historical service environment dataset B corresponding to the service name when the RunService record index is 'a', and execute Step 4.7;

[0149] Step 4.7: Use datasets A and B to obtain the normal data containing the service running and service environment of the RunService record with index a, store it in the list NormData, and execute Step 4.8;

[0150] Step 4.8: Obtain the currently monitored service running and service environment data for the service represented by the service name with the RunService record index 'a', store it in the list AbnormData, and then execute Step 4.9.

[0151] Step 4.9: Determine if g is less than the number of attributes of the data recorded in the list NormDataList. If the condition is true, proceed to Step 4.10; otherwise, proceed to Step 4.14.

[0152] Step4.10. Initialize the list PDict to store the stationarity of the g-th column of the ADF test for NormData. Execute Step4.11 with the results containing information such as the p-value and confidence level. The ADF test is used to determine whether a sequence has a unit root: if the sequence is stationary, there is no unit root; otherwise, there is a unit root.

[0153] Step4.11. Judge if PDict[1]<0.05&&PDict[0]<PDict[4]['5%']. If the condition holds, execute Step4.12; otherwise, execute Step4.13. Here, PDict[1] is the p-value of the ADF test, PDict[0] is the statistic of the ADF test, and PDict[4]['5%'] is the threshold of the statistic at the 5% confidence level.

[0154] Step4.12. Store the column name of the g-th column of NormData into ColumnList and execute Step4.13.

[0155] Step4.13. g++; Execute Step4.9.

[0156] Step4.14. Initialize e = 0 and execute Step4.15. [[ID=~13]]

[0157] Step4.15. Judge if e<3. If the condition holds, execute Step4.16; otherwise, execute Step4.24.

[0158] Step4.16. Randomly select 10% of the samples from NormData and store them in NormDataList, then execute Step4.17.

[0159] Step4.17. Initialize h = 0; Initialize an empty list PList to store the t-test results and execute Step4.18. The t-test uses the t-distribution theory to infer the probability of a difference occurring, thereby comparing whether the difference between two means is significant. The t-test statistic is: where i = 1,...,n, is the sample mean, is the sample standard deviation, and n is the number of samples.

[0160] Step4.18. Judge if h is less than the length of the list ColumnList. If the condition holds, execute Step4.19; otherwise, execute Step4.21.

[0161] Step 4.19: Perform a t-test on the data with column name ColumnList and index h in NormDataList and NormData, store the output in PList, and then execute Step 4.20;

[0162] Step 4.20, h++, execute Step 4.18;

[0163] Step 4.21: Initialize the variable Pnorm to store the mean of all elements in PList, then execute Step 4.22;

[0164] Step 4.22: Add Pnorm to PnormList, then proceed to Step 4.23;

[0165] Step 4.23, e++, execute Step 4.15;

[0166] Step 4.24: Initialize the variable Prealnorm to store the mean of all elements in PnormList, initialize the temporary variable L = 0, and empty list PList to store the t-test results. Then execute Step 4.25.

[0167] Step 4.25: If L is less than the length of the list ColumnList, execute Step 4.26 if the condition is true; otherwise, execute Step 4.28.

[0168] Step 4.26: Perform a t-test on the data with index L in the records of column name ColumnList in NormData and AbNormData, store the output results in TList, and then execute Step 4.27;

[0169] Step 4.27, L++, execute Step 4.25;

[0170] Step 4.28: Initialize variable Pabnorm to store the mean of all elements in TList, initialize variable k to store the probability of service failure, k = 1 - lg(Pabnorm) / lg(Prealnorm), initialize service failure probability threshold Threshold = 0.9, where lg() represents the logarithm operation, and execute Step 4.29.

[0171] Step 4.29: Determine if k is greater than Threshold. If the condition is true, proceed to Step 4.30; otherwise, proceed to Step 4.32.

[0172] Step 4.30: Add the data with index 'a' to the list RunService in BreakService, and then execute Step 4.31;

[0173] Step 4.31, a++, execute Step 4.3;

[0174] Step 4.32: Add the data with index 'a' to the RunService list in OtherService, add 'k' to the ServiceExcept list, and execute Step 4.31. Example 2: The specific steps of the method are as follows: The service call data attribute table is shown in Table 1;

[0175] Table 1 Service Invocation Data Attribute Table

[0176] CallId Service call number ServiceUser Service User Name ServicePro Service Name ServiceRunStatuss Service call status

[0177] Furthermore, the specific steps of the method can be set as follows, with Step 1 specifically as follows:

[0178] Step 1.1: Read the service call dataset D monitored in the cloud environment, extract the service call data from the service call dataset D, separate the attributes of the service call data with colons, store it in the initialization list ServiceDataList, initialize the temporary variable i = 0, and execute Step 1.2; The attributes of the service call data include service call number, service user name, service name, and service call status;

[0179] Table 2 Service Invocation Dataset

[0180] Call ServiceUser ServicePro ServiceRunStatus 0 Hotel Cinema Working 1 Hotel Wineshop Working 2 Plane Hotel Working 3 ScenicSpot Train End

[0181] ServiceDataList=[0:Hotel:Cinema:Working, 1:Hotel:Wineshop:Working, 2:Plane:Hotel:Working, 3:ScenicSpot:Train:End];

[0182] Step 1.2: Initialize the variable ServiceStatus1 = "Working", initialize an empty list TransferList, which stores the running status service call data, and then proceed to Step 1.3;

[0183] Step 1.3: Determine if i is less than the length of the list ServiceDataList. If the condition is true, proceed to Step 1.4; otherwise, proceed to Step 2.

[0184] When i = 0, since the length of the ServiceDataList list is 4 and 0 < 4, Step 1.4 is executed;

[0185] When i = 4, since the length of the list ServiceDataList is 4, and 4! < 4, Step 2 is executed;

[0186] Step 1.4: Initialize the variable ServiceRunStatus to store the service call status obtained from the data at index i in the ServiceDataList. Then execute Step 1.5.

[0187] When i = 0, ServiceRunStatus = "Working"; when i = 2, ServiceRunStatus = "End".

[0188] Step 1.5: Determine if ServiceRunStatus is equal to ServiceStatus1. If the condition is true, proceed to Step 1.6; otherwise, proceed to Step 1.7.

[0189] When i = 0, since ServiceStatus1 = "Working" and ServiceRunStatus = "Working", Step 1.6 is executed;

[0190] When i = 3, since ServiceStatus1 = "Working" and ServiceRunStatus = "End", Step 1.7 is executed;

[0191] Step 1.6: Add the data with index i to the ServiceDataList in the TransferList, then proceed to Step 1.7;

[0192] When i = 0, TransferList adds the record "0:Hotel:Cinema:Working";

[0193] Step 1.7, i++, execute Step 1.3; by looping through Step 1.3 to Step 1.7, the final list of running services is as follows: TransferList = [0:Hotel:Cinema:Working, 1:Hotel:Wineshop:Working, 2:Plane:Hotel:Working].

[0194] Step 2 is described in detail below:

[0195] Step 2.1: Read the list of running service calls, TransferList, initialize an empty list ServiceInteractive to store the service interaction graph, and initialize the temporary variable j = 0;

[0196] TransferList=[0:Hotel:Cinema:Working, 1:Hotel:Wineshop:Working, 2:Plane:Hotel:Working];

[0197] Step 2.2: Is j less than the length of the list TransferList? If the condition is true, proceed to Step 2.3; otherwise, proceed to Step 2.11.

[0198] When j = 0, since the length of the list TransferList is 3, and 0 < 3, Step 2.3 is executed;

[0199] When j = 3, since the length of the list TransferList is 3, and 3! < 3, Step 2.11 is executed;

[0200] Step 2.3: Use the list TransferList to record the data at index j, obtain the service user name and store it in the initialization variable SerUser, obtain the service name and store it in the initialization variable SerPro, obtain the service call status and store it in the initialization variable SerStatus, obtain the service call number and store it in the initialization variable CallId, initialize the temporary variable h = 0, and execute Step 2.4.

[0201] When j = 0, Step 2.4 is executed because of the use of TransferList.get(0) = "0:Hotel:Cinema:Working", SerUser = "Hotel", SerPro = "Cinema", SerStatus = "Working";

[0202] Step 2.4: Determine if h is less than the length of the ServiceInteractive list. If the condition is true, proceed to Step 2.5; otherwise, proceed to Step 2.10.

[0203] When j=0 and h=0, since the length of the ServiceInteractive list is 0 and 0! < 0, Step 2.10 is executed;

[0204] When j=1 and h=0, since the length of the ServiceInteractive list is 1 and 0<1, Step 2.5 is executed;

[0205] Step 2.5: Initialize the String type variable ServiceUser1 to store the service user name obtained from the data at index h of the ServiceInteractive record. Execute Step 2.6. When j = 1 and h = 0, since the data at index h of the ServiceInteractive record is "Hotel:0-Working(Cinema)" and ServiceUser1 is "Hotel", execute Step 2.6.

[0206] Step 2.6: Determine if ServiceUser1 is equal to SerUser. If the condition is true, proceed to Step 2.7; otherwise, proceed to Step 2.9.

[0207] When j=1 and h=0, since ServiceUser1=SerUser=“Hotel”, Step 2.7 is executed;

[0208] When j=2 and h=0, since ServiceUser1="Hotel" and SerUser="Plane", Step 2.9 is executed;

[0209] Step 2.7: Replace the data at index h of the ServiceInteractive record in the list with the data at index h of the ServiceInteractive record + CallId + "-" + SerStatus + "("SerPro + ")", then execute Step 2.8; When j = 1 and h = 0, replace the data at index 0 of the ServiceInteractive list with "Hotel:0-Working(Cinema)1-Working(Wineshop)"), then execute Step 2.8;

[0210] Step 2.8, j++, execute Step 2.2;

[0211] Step 2.9, h++, execute Step 2.4;

[0212] Step 2.10: Add SerUser+“:”CallId+“-”SerStatus+“(”SerPro+“)” to the ServiceInteractive list, then execute Step 2.8;

[0213] When j=0 and h=0, ServiceInteractive adds "Hotel:0-Working(Cinema)" and executes Step 2.8;

[0214] Step 2.11: Monitor new service call data in real time, obtain the service user name and store it in the initialization variable ServiceUser, obtain the service name and store it in the initialization variable ServicerPro, obtain the service call status and store it in the initialization variable ServiceStatus, obtain the call number and store it in the initialization variable ServiceCallId, initialize the temporary variable p=0, and execute Step 2.12.

[0215] When the real-time monitoring shows a new service call data of "4:Hotel:Plane:Working", ServiceUser = "Hotel", ServicePro = "Plane", ServiceStatus = "Working", and ServiceCallId = "4".

[0216] Step 2.12: Read the list of ServiceInteractive that stores service interaction graphs, and then execute Step 2.13;

[0217] ServiceInteractive=[Hotel:0-Working(Cinema)1-Working(Wineshop),Plane:2-Working(Hotel)], execute Step2.13;

[0218] Step 2.13: Check if ServiceStatus equals "Working". If the condition is true, proceed to Step 2.14; otherwise, proceed to Step 2.20.

[0219] When the real-time monitoring shows a new service call data of "4:Hotel:Plane:Working", ServiceStatus = "Working", and Step 2.14 is executed;

[0220] When the real-time monitoring shows a new service call data of "0:Hotel:Cinema:End", ServiceStatus = "End", and Step 2.20 is executed;

[0221] Step 2.14: Is p less than the length of the list ServiceInteractive? If the condition is true, proceed to Step 2.15; otherwise, proceed to Step 2.19.

[0222] When p = 0, since the length of the ServiceInteractive list is 2, and 0 < 2, Step 2.15 is executed;

[0223] When p = 2, since the length of the list ServiceInteractive is 2, and 2! < 2, Step 2.19 is executed;

[0224] Step 2.15: Initialize the String type variable ServerUser to store the service user name obtained by using the data at index p of the ServiceInteractive list, and then execute Step 2.16;

[0225] When p=1, since the data with index 1 in the list ServiceInteractive is "Plane:2-Working(Hotel)" and ServerUser is "Plane", Step 2.16 is executed;

[0226] Step 2.16: Determine if ServerUser is equal to ServiceUser. If the condition is true, proceed to Step 2.17; otherwise, proceed to Step 2.18.

[0227] When the real-time monitoring shows a new service call data of "4:Hotel:Plane:Working" and p=0, ServerUser=ServiceUser="Hotel", and Step 2.17 is executed;

[0228] When the real-time monitoring shows a new service call data of "6:Wineshop:Plane:Working" and p=0, ServerUser="Hotel", ServiceUser="Wineshop", and Step 2.18 is executed;

[0229] Step 2.17: Replace the data at index p of the ServiceInteractive record in the list with the data at index p of the ServiceInteractive record + ServiceCallId + "-" ServiceStatus + "(" + ServicePro + ")"), then execute Step 3;

[0230] When the real-time monitoring shows a new service call data of "4:Hotel:Plane:Working" and p=0, the data with index 0 in the ServiceInteractive list is replaced with Hotel:0-Working(Cinema)1-Working(Wineshop)4-Working(Plane), and Step 3 is executed;

[0231] Step 2.18, p++, execute Step 2.14;

[0232] Step2.19, ServiceInteractive adds ServiceUser+":"+ServiceCallId+":"+ServiceStatus+"("+ServicePro+")") and execute Step3;

[0233] When the real-time monitoring shows a new service call data of "6:Wineshop:Plane:Working" and p=2, add "Wineshop:6-Working(Plane)" to the ServiceInteractive list and execute Step 3;

[0234] Step 2.20: Determine if p is less than the length of the list ServiceInteractive. If the condition is true, proceed to Step 2.21; otherwise, proceed to Step 2.29.

[0235] When p = 0, since the length of the ServiceInteractive list is 2, and 0 < 2, Step 2.21 is executed;

[0236] When p = 2, since the length of the list ServiceInteractive is 2, and 2! < 2, Step 2.29 is executed;

[0237] Step 2.21: Initialize the list ServerCallId to store the service call number obtained by using the data with index p recorded by ServiceInteractive; initialize the String type variable Seruser to store the service user name obtained by using the data with index p recorded by ServiceInteractive; initialize the temporary variable q = 0; and execute Step 2.22.

[0238] When p=0, since the data with index 0 of ServiceInteractive is "Hotel:0-Working(Cinema)1-Working(Wineshop)", ServerCallId=[0,1], Seruser="Hotel", Step2.22 is executed;

[0239] Step 2.22: Determine if Seruser is equal to ServiceUser. If the condition is true, proceed to Step 2.23; otherwise, proceed to Step 2.28.

[0240] When the real-time monitoring shows a new service call data of "0:Hotel:Cinema:End" and p=0, ServiceUser=Seruser="Hotel", and Step 2.23 is executed;

[0241] When the real-time monitoring shows a new service call data of "6:Wineshop:Plane:End" and p=0, ServiceUser="Wineshop" and Seruser="Hotel", then execute Step 2.28;

[0242] Step 2.23: Determine if q is less than the length of the list ServerCallId. If the condition is true, proceed to Step 2.24; otherwise, proceed to Step 2.27.

[0243] When p=0, q=0, and the new service call data being monitored in real time is “0:Hotel:Plane:End”, the length of the ServerCallId list is 2, 0<2, and Step2.24 is executed;

[0244] When p=0, q=2, and the new service call data being monitored in real time is "7:Hotel:Cinema:End", the length of the ServerCallId list is 2, 2! < 2, so Step 2.27 is executed;

[0245] Step 2.24: Check if the data with index q in the ServerCallId list is equal to ServiceCallId. If the condition is true, proceed to Step 2.25; otherwise, proceed to Step 2.26.

[0246] When the new service call data being monitored in real time is "0:Hotel:Cinema:End", p=0, q=0, since the index of the ServerCallId record is 0 and the data is "0", ServiceCallId = "0", Step 2.25 is executed;

[0247] When the new service call data being monitored in real time is "7:Hotel:Cinema:End" p=0, q=0, the data with ServerCallId index 0 is "0", ServiceCallId is "7", and Step 2.26 is executed;

[0248] Step 2.25: Use the current service call data obtained from ServiceUser, ServicePro, ServiceStatus, and ServiceCallId to update ServiceInteractive, then proceed to Step 3;

[0249] When the real-time monitoring of new service call data is "0:Hotel:Cinema:End", p=0, q=0, because ServiceUser="Hotel", ServicePro="Cinema", ServiceStatus="End", ServiceCallId="0";

[0250] ServiceInteractive=[Hotel:0-End(Cinema)1-Working(Wineshop),Plane:2-Working(Hotel)];

[0251] Step 2.26, q++, execute Step 2.23;

[0252] Step 2.27: Replace the data at index p of the ServiceInteractive record in the list with the data at index p of the ServiceInteractive record in the list + ServiceCallId + "-" ServiceStatus + "(" + ServicePro + ")"), then execute Step 3;

[0253] When the real-time monitoring shows a new service call data of "7:Hotel:Cinema:End", p=0, q=2, the data with index 0 of the ServiceInteractive list is replaced with "Hotel:0-Working(Cinema)1-Working(Wineshop)7-End(Cinema)", and Step 3 is executed.

[0254] Step 2.28, p++, execute Step 2.20;

[0255] Step 2.29: Add ServiceUser+“:”+ServiceCallId+“-”+ServiceStatus+“(”+ServicePro+“) to the ServiceInteractive list, and execute Step 3; When the new service call data being monitored in real time is “6:Wineshop:Plane:End”, p=2, add “Wineshop:6-End(Plane)” to ServiceInteractive, and execute Step 3.

[0256] As can be seen from the Step 2 process, each time a service call data is monitored in real time, causing a change in the service interaction graph, the Step 2 process can be ended and the subsequent process can be executed. The following Step 3 embodiment will use the result after several service interaction graph changes as an example to illustrate the subsequent process.

[0257] Step 3 is described in detail below:

[0258] Step 3.1: Read the Service Interaction Graph list ServiceInteractive, then execute Step 3.2;

[0259] ServiceInteractive=[Hotel:0-End(Cinema)1-Working(Wineshop)4-Working(Plane)7-End(Cinema)5-Working(Cinema),Plane:2-Working(H otel)11-End(Train),Wineshop:6-End(Plane)9-Working(Plane),Cinema:8-Working(Hotel)12-Working(Train),Train:10-Working(Hotel)];

[0260] Step 3.2: Initialize an empty list ServiceRelationship to store the service relationship graph, initialize the temporary variable x = 0, and then execute Step 3.3;

[0261] Step 3.3: Determine if x is less than the length of the ServiceInteractive list. If the condition is true, proceed to Step 3.4; otherwise, proceed to Step 4.

[0262] When x = 0, the length of the ServiceInteractive list is 5, 0 < 5, so Step 3.4 is executed;

[0263] When x = 5, the length of the ServiceInteractive list is 5. Since 5! < 5, proceed to Step 4.

[0264] Step 3.4: Use the list ServiceInteractive to record the data at index x, obtain the service name and store it in the initialization list ServiceProvide, obtain the service user name and store it in the initialization variable ServiceUser, obtain the service call status and store it in the initialization list ServiceStatus, remove duplicates from the list ServiceProvide and store them in the initialization list Ser, initialize the temporary variable y = 0, initialize the temporary variable z = 0, and execute Step 3.5.

[0265] When x = 2, the index of the ServiceInteractive list is x = "Wineshop:6-End(Plane)9-Working(Plane)", ServiceProvide = [Plane,Plane], ServiceUser = "Wineshop", ServiceStatus = [End,Working], Ser = [Plane]. Execute Step 3.5; Step 3.5: Determine if y is less than the length of the Ser list. If the condition is true, execute Step 3.6; otherwise, execute Step 3.13.

[0266] When x = 2 and y = 0, the length of list Ser is 1, 0 < 1, so Step 3.6 is executed;

[0267] When x = 2 and y = 1, the length of list Ser is 1, and 1! < 1, so Step 3.13 is executed;

[0268] Step 3.6: Initialize ServiceFrequency to store the frequency of calls to the same service. ServiceFrequency = 0, SerRelationship = ServiceUser + ":" to store service relationships. Then proceed to Step 3.7.

[0269] Step 3.7: Is z less than the length of the ServiceProvide list? If the condition is true, proceed to Step 3.8; otherwise, proceed to Step 3.11.

[0270] When x = 2 and z = 0, the length of the ServiceProvide list is 2, and 0 < 2, so Step 3.8 is executed;

[0271] When x = 2 and z = 2, the length of the ServiceProvide list is 2, and 2! < 2, so Step 3.11 is executed;

[0272] Step 3.8: Is the data at index y of the Ser record in the list equal to the data at index z of the ServiceProvide record in the list? And is the data at index z of the ServiceStatus record equal to "Working"? If the conditions are true, proceed to Step 3.9; otherwise, proceed to Step 3.10.

[0273] When x = 2, y = 0, z = 1, since the data of the Ser record with index 0 = the data of the ServiceProvide record with index 1 = "Plane" and the data of the ServiceStatus record with index 1 = "Working", Step 3.9 is executed;

[0274] When x = 2, y = 0, z = 0, since the data of the Ser record with index 0 = the data of the ServiceProvide record with index 0 = "Plane", and the data of the ServiceStatus record with index 0 = "End", Step 3.10 is executed;

[0275] Step 3.9, ServiceFrequency++, then proceed to Step 3.10;

[0276] Step 3.10, z++, then execute Step 3.7;

[0277] Step 3.11: SerRelationship = SerRelationship + ServiceFrequency "(" + data of index y in list Ser + ")", then execute Step 3.12;

[0278] When x = 2, since SerRelationship = "Wineshop:", SerRelationship = "Wineshop:1(Plane)", Step 3.12 is executed;

[0279] Step 3.12, y++, then execute Step 3.5;

[0280] Step 3.13: Add SerRelationship to the ServiceRelationship list, then proceed to Step 3.14;

[0281] When x = 2 and y = 1, add "Wineshop:1(Plane)" to ServiceRelationship;

[0282] Step 3.14, x++, execute Step 3.3.

[0283] Step 4 is described in detail below:

[0284] Step 4.1: Read the ServiceRelationship list containing the service relationship diagram and execute Step 4.2; after completing Step 3, ServiceRelationship = [Hotel:1(Cinema)1(Wineshop)1(Plane),Plane:1(Hotel)0(Train),Wineshop:1(Plane),Cinema:1(Hotel)1(Train),Train:1(Hotel)];

[0285] Step 4.2: Initialize the RunService list to store the names of services currently in operation obtained using ServiceRelationship; initialize the empty ServiceExcept list to store service names other than the faulty service names and the probability of failure of the service represented by each service name; initialize the empty OtherService list to store service names other than the faulty service names; initialize the empty BreakService list to store the faulty service names; initialize the temporary variable a = 0; execute Step 4.3; RunService = [Cinema, Wineshop, Plane, Hotel, Train]; execute Step 4.3.

[0286] Step 4.3: Determine if 'a' is less than the length of the RunService list. If the condition is true, proceed to Step 4.4; otherwise, proceed to Step 5.

[0287] When a = 0, the length of the list RunService is 5, 0 < 5, so execute Step 4.4; when a = 5, the length of the list RunService is 5, 5! < 5, so execute Step 5; Step 4.4: Initialize an empty two-dimensional list NormDataList r*c This is used to store the sample data of the RunService record with index 'a'. An empty list ColumnList is initialized to store column names, and an empty list PnormList is initialized to store the sample hypothesis test probability values ​​of the RunService record with index 'a'. A temporary variable g is initialized to 0, and Step 4.5 is executed. Where NormDataListr*c = [[J1],[J2],[J3],...,[Jr]], [J1] = [M1,M2,M3,...,Mc], J1 is the first record containing data about the service's operation and service environment, J... r For the r-th entry containing data about service operation and service environment, Mc Let r be the c-th attribute of the first data item containing service operation and service environment data, r be the total number of data items in the list containing service operation and service environment data, and c be the total number of attributes for each data item.

[0288] Step 4.5: Input the service runtime dataset A and execute Step 4.6; (The following explanation mainly uses the runtime data of the service "Hotel");

[0289] Table 3 Service Operation Data Attribute Table

[0290] %usr Percentage of CPU used by the service process in user space %system Percentage of CPU used by the service process in kernel space %guest Percentage of CPU used by the service process in the virtual machine %mem Percentage of memory used by the service process kBrd / s The service process reads KB from the disk per second kBwr / s The service process writes KB to disk per second

[0291] Table 4 Hotel Service Operation Data Table

[0292] %usr %system %guest %mem kBrd / s kBwr / s 0.61 0.55 0.7 0.38 0.54 0.31 0.82 0.41 0.35 0.34 1.29 0.09 0.56 0.73 0.15 0.43 1.74 0.89 0.68 0.99 0.13 0.37 0.01 0.30 0.47 0.35 0.53 0.41 0.77 0.54 0.35 0.61 0.13 0.49 0.64 0.23 0.84 0.57 0.09 0.50 0.12 0.03 0.59 0.88 0.23 0.46 0.40 0.01 0.92 0.51 0.43 0.45 0.45 0.47 0.10 0.39 0.13 0.39 0.46 0.31 0.57 0.32 0.22 0.32 0.54 1.38 0.15 0.92 0.50 0.32 0.14 0.09 0.73 0.99 0.75 0.33 1.75 0.24 0.6 0.05 0.65 0.32 0.24 0.78 0.2 0.81 0.11 0.31 0.23 1.37 0.71 0.16 0.24 0.32 0.57 0.89 0.44 0.51 0.50 0.37 0.24 1.15 0.8 0.84 0.53 0.42 0.98 1.24 0.5 0.07 0.41 0.22 0.08 0.52 0.54 0.7 0.7 0.29 0.14 0.18

[0293] Step 4.6: Input service environment dataset B and execute Step 4.7 (the following mainly uses the CPU environment data of the service "Hotel" for explanation);

[0294] Table 5 Service Environment Data Attribute Table

[0295]

[0296] Table 6 Service Hotel Environment Data Table

[0297] CPU user CPU sys CPU free 6 8 86 4 14 82 5 11 84 2 13 84 3 11 86 3 4 93 6 5 92 4 11 85 3 11 86 3 10 87 19 10 71 5 13 82 4 9 87 5 4 91 8 6 86 9 14 77 3 13 84 5 4 91 9 14 77 6 11 83

[0298] Step 4.7: Use datasets A and B to obtain the normal data containing the service running and service environment (normal data refers to the data of the service in a normal state, i.e., data without faults) of the RunService record with index a, store it in the list NormData, and execute Step 4.8;

[0299] When a = 3, NormData = [[0.61,0.55,0.7,0.38,0.54,0.31,6.0,8.0,86.0],[0.82,0.41,0.35,0.34,1.29,0.09,4.0,14.0,82.0],[0.56,0.73,0.15,0.43,1.74,0.89,5.0,11.0,84.0],[0.68,0.99,0.13,0.37,0.01,0.30,3.0,13.0,84.0],[0.47,0.35,0.53,0.41,0.77,0.54,3.0, 11.0,86.0],[0.35,0.61,0.13,0.49,0.64,0.23,3.0,4.0,93.0],[0.84,0.57,0.09,0.50,0.12,0.03,3.0,5.0,92.0],[0.59,0.88,0.23,0.46,0.40,0.01,4.0,11.0,85.0],[0.92,0.51,0.43,0.45,0.45,0.47,3.0,11.0,86.0],[0.1,0.39,0.13,0.39,0.46,0.31,3.0,10.0,8 7.0],[0.57,0.32,0.22,0.32,0.54,1.38,19.0,10.0,71.0],[0.15,0.92,0.5,0.32,0.14,0.09,5.0,13.0,82.0],[0.73,0.99,0.75,0.33,1.75,0.57,4.0,9.0,87.0],[0.6,0.05,0.65,0.32,0.24,0.78,5.0,4.0,91.0],[0.2,0.81,0.11,0.31,0.23,1.37,8.0,6.0,86.0],[0 [0.71,0.16,0.24,0.32,0.57,0.89,9.0,14.0,77.0],[0.44,0.51,0.5,0.37,0.24,1.15,3.0,13.0,84.0],[0.8,0.84,0.53,0.42,0.98,1.24,5.0,4.0,91.0],[0.5,0.07,0.41,0.22,0.08,0.52,9.0,14.0,77.0],[0.54,0.7,0.7,0.29,0.14,0.18,6.0,11.0,83.0]], execute Step 4.8;

[0300] Step 4.8. Obtain the currently monitored service operation and service environment data of the service represented by the service name with the RunService record index a, store it in the list AbnormData, and execute Step 4.9;

[0301] When a = 3, AbnormData = [[0.92, 0.51, 0.45, 0.22, 0.0, 0.0, 70.0, 5.0, 30.0]], execute Step 4.9;

[0302] (Take the 7th, 8th, and 9th columns of the lists NormData and AbnormData as an example)

[0303] Step 4.9. Determine whether g is less than the number of attributes of the data recorded in the list NormDataList. If the condition is true, execute Step 4.10; otherwise, execute Step 4.14. When a = 3 and g = 6, since 6 < 9, execute Step 4.10. When a = 3 and g = 9, since 9! < 9, execute Step 4.14;

[0304] Step 4.10. Initialize the list PDict to store the stationarity of the g-th column of NormData in the ADF test. Execute Step 4.11 with the results containing probability values, confidence levels, etc. The ADF test is to determine whether there is a unit root in the sequence: if the sequence is stationary, there is no unit root; otherwise, there is a unit root;

[0305] When a = 3 and g = 6, PDict = [0.4577085703281921, 0.9835293891291814, 8, 11, {'1%': -4.223238279489106, '5%': -3.189368925619835, '10%': -2.729839421487603}, 5.500801908334559], execute Step 4.11;

[0306] Step 4.11. Determine whether PDict[1] < 0.05 && PDict[0] < PDict[4]['5%']. If the condition is true, execute Step 4.12; otherwise, execute Step 4.13. Here, PDict[1] is the probability value of the ADF test, PDict[0] is the statistic of the ADF test, and PDict[4]['5%'] is the threshold of the statistic at the 5% confidence level;

[0307] When a = 3 and g = 7, PDict[1] < 0.05 && PDict[0] < PDict[4]['5%']. Since 0.0002654314332114105 < 0.05 and -4.4273592235697885 < -3.0312271701414204, execute Step4.12;

[0308] When a = 3 and g = 6, PDict[1] < 0.05 && PDict[0] < PDict[4]['5%']. Since 0.9835293891291814! < 0.05 and 0.4577085703281921! < -3.189368925619835, execute Step4.13;

[0309] Step4.12: Store the column name of the g-th column of NormData into ColumnList, and execute Step4.13;

[0310] When a = 3 and g = 8, ColumnList = ['cpu_sys', 'cpu_free'], and execute Step4.13;

[0311] Step4.13: g++; Execute Step4.9;

[0312] Step4.14: Initialize e = 0, and execute Step4.15;

[0313] Step4.15: Judge whether e < 3. If the condition holds, execute Step4.16; otherwise, execute Step4.24;

[0314] When e = 0, 0 < 3, execute Step4.16; when e = 3, 3! < 3, execute Step4.24;

[0315] Step4.16: Randomly sample 10% of the samples from NormData and store them in NormDataList, and execute Step4.17;

[0316] When a = 3 and e = 0, NormDataList = [[5.0, 4.0, 91.0], [3.0, 10.0, 87.0]], and execute Step4.17;

[0317] Step4.17: Initialize the temporary variable h = 0; Initialize an empty list PList to store the t-test results, and execute Step4.18, where the t-test uses the t-distribution theory to infer the probability of the difference occurring, so as to compare whether the difference between two averages is significant;

[0318] Step 4.18: Determine if h is less than the length of the list ColumnList. If the condition is true, proceed to Step 4.19; otherwise, proceed to Step 4.21.

[0319] When h = 0, 0 < 2, execute Step 4.19; when h = 2, 2! < 2, execute Step 4.21;

[0320] Step 4.19: Perform a t-test on the data with column name ColumnList and index h in NormDataList and NormData, store the output in PList, and then execute Step 4.20;

[0321] When a = 3, e = 0, h = 1, PList = [0.0019382150159351873, 0.0020235363050357456], execute Step 4.20;

[0322] Step 4.20, h++, execute Step 4.18;

[0323] Step 4.21: Initialize the variable Pnorm to store the mean of all elements in PList, and execute Step 4.22; when a = 3 and e = 0, Pnorm = (0.0019382150159351873 + 0.0020235363050357456) / 2 = 0.0019808756604854667, and execute Step 4.22;

[0324] Step 4.22: Add Pnorm to PnormList, then proceed to Step 4.23;

[0325] When a = 3, e = 0, and PnormList = [0.0019808756604854667], execute Step 4.23;

[0326] Step 4.23, e++, execute Step 4.15;

[0327] Step 4.24: Initialize the variable Prealnorm to store the mean of all elements in PnormList, initialize the temporary variable L = 0, and empty list PList to store the t-test results. Then execute Step 4.25.

[0328] When a = 3, Prealnorm(0.0019808756604854667+0.19485980547535092+0.3530692367584899) / 3 = 0.18330330596477543, and Step 4.25 is executed;

[0329] Step 4.25: If L is less than or equal to the length of ColumnList, execute Step 4.26; otherwise, execute Step 4.28.

[0330] When a = 3, L = 0, 0 < 2, execute Step 4.26; when a = 3, L = 2, 2! < 2, execute Step 4.28;

[0331] Step 4.26: Perform a t-test on the data with index L in the ColumnList records of NormData and AbNormData, store the output in TList, and execute Step 4.27; when a=3 and L=0, TList=[3.006744000772957e-16], execute Step 4.27;

[0332] Step 4.27, L++, execute Step 4.25;

[0333] Step 4.28: Initialize variable Pabnorm to store the mean of all elements in TList, initialize variable k to store the probability of service failure, k = 1 - lg(Pabnorm) / lg(Prealnorm), initialize service failure probability threshold Threshold = 0.9, where lg() represents the logarithm operation, and execute Step 4.29.

[0334] When a = 3, Pabnorm = (3.006744000772957e-16 + 5.52418902620316e-24) / 2 = 1.0022480186716158e-16, k = 1 - lg(0.18330330596477543) / lg(1.0022480186716158e-16) = 0.95 (rounded to two decimal places), proceed to Step 4.29;

[0335] Step 4.29: Determine if k is greater than Threshold. If the condition is true, proceed to Step 4.30; otherwise, proceed to Step 4.32.

[0336] When a = 0, 0.79! > 0.9, so execute Step 4.32; when a = 3, 0.95 > 0.9, so execute Step 4.30.

[0337] Step 4.30: BreakService adds a record to the RunService list with index 'a', then executes Step 4.42.

[0338] When a = 3, BreakService.add(“Hotel”);

[0339] Step 4.31, a++, execute Step 4.3;

[0340] Step 4.32: Add the data with index 'a' to the RunService list in OtherService, add 'k' to the ServiceExcept list, and execute Step 4.31. When a = 5, OtherService = [Cinema, Wineshop, Plane, Train], ServiceExcept = [Cinema:0.50, Wineshop:0.67, Plane:0.83, Train:0.59], and execute Step 4.31.

[0341] Step 5 is described in detail below:

[0342] Step 5.1: Read the ServiceRelationship list, the BreakService list, the ServiceExcept list, and the OtherService list. Then execute Step 5.2. ServiceRelationship = [Hotel:1(Cinema)1(Wineshop)1(Plane),Plane:1(Hotel)0(Train),Wineshop:1(Plane),Cinema:1(Hotel)1(Train),Train:1(Hotel)]; BreakService = [Hotel]; ServiceExcept = [Cinema:0.50,Wineshop:0.67,Plane:0.83,Train:0.59]; OtherService = [Cinema,Wineshop,Plane,Train]. Execute Step 5.2.

[0343] Step 5.2: Initialize the empty list Path to store the service failure propagation path, initialize the temporary variable w = 0, initialize the temporary variable m = 0, and execute Step 5.3;

[0344] Step 5.3: Determine if w is less than the length of the list BreakService. If the condition is true, proceed to Step 5.4; otherwise, proceed to Step 5.45.

[0345] When w = 0, since the length of the list BreakService is 1 and 0 < 1, Step 5.5 is executed;

[0346] When w=1, since the length of the list BreakService is 1, and 1! < 1, Step 5.45 is executed;

[0347] Step 5.4: Initialize an empty list Correlation to store the similarity between services, then proceed to Step 5.5;

[0348] Step 5.5: Determine if m is less than the length of the OtherService list. If the condition is true, proceed to Step 5.6; otherwise, proceed to Step 5.9.

[0349] When m = 0, the length of the OtherService list is 4, 0 < 4, so Step 5.6 is executed;

[0350] When m=4, the length of the list OtherService is 4, and 4! < 4, so Step 5.9 is executed;

[0351] Step 5.6: Perform pruning operations on ServiceRelationship. Execute Step 5.7, where pruning only retains service relationships that are currently running; ServiceRelationship = [Hotel:1(Cinema)1(Wineshop)1(Plane),Plane:1(Hotel),Wineshop:1(Plane),Cinema:1(Hotel)1(Train),Train:1(Hotel)];

[0352] Step 5.7: Add the WSimRank algorithm to the Correlation to calculate the similarity between the service with record index w of BreakService and the service with record index m of OtherService. Then execute Step 5.8, where the similarity is calculated using the WSimRank algorithm. Set the number of iterations for the WSimRank algorithm. The WSimRank algorithm is as described in the invention content.

[0353] When w=0 and m=0, the similarity between the service Hotel and Cinema is calculated to be 0.49 (rounded to two decimal places), and is added to the list Correlation;

[0354] Step 5.8, m++, then execute Step 5.9;

[0355] Step 5.9: Initialize the empty list Propagation to store the calculated service failure propagation probability. Initialize u = 0 and execute Step 5.10.

[0356] Step 5.10: Is u less than the length of the OtherService list? If the condition is true, proceed to Step 5.11; otherwise, proceed to Step 5.13.

[0357] When w=0 and u=0, the length of the list OtherService is 4, 0<4, so Step5.11 is executed;

[0358] When w = 0 and u = 4, the length of the list OtherService is 4, and 4! < 4, so Step 5.13 is executed;

[0359] Step 5.11: Add the list Correlation to the list Propagation, record the data with index u, and the list ServiceExcept to record the failure probability of the service with index u. Then proceed to Step 5.12.

[0360] When w=0, u=0, add data with index 0 to the Correlation record in the Propagation list * data with index 0 in the ServiceExcept list. The probability of service failure is 0.49 * 0.50 = 0.25 (rounded to two decimal places). Execute Step 5.12.

[0361] Step 5.12, u++, execute Step 5.10;

[0362] Step 5.13: Initialize the service failure propagation probability threshold Pthreshold. Initialize the list PathInterim to store temporary paths. Add the list BreakService to the list PathInterim to record the data with index w. Execute Step 5.14.

[0363] When w = 0 and Pthreshold = 0.4, PathInterim.add(“Hotel”);

[0364] Step 5.14: Initialize the temporary variable v = 0, initialize the list Part1, execute Part1.addAll(PathInterim) on Part1, and execute Step 5.15; where Part1.addAll(PathInterim) means that Part1 overwrites and adds the list PathInterim.

[0365] In the first loop, when w = 0, Part1.addAll(“Hotel”);

[0366] Step 5.15: Determine if v is less than the length of list Part1. If the condition is true, proceed to Step 5.16; otherwise, proceed to Step 5.27.

[0367] In the first loop, when w=0 and v=0, since the length of list Part1 is 1 and 0<1, Step5.16 is executed;

[0368] In the first loop, when w=0 and v=1, since the length of list Part1 is 1 and 1! < 1, Step5.27 is executed;

[0369] Step 5.16: Initialize temporary variable n = 0, initialize temporary variable z = 0, initialize list OutNode to store the name of the running successor node service of the last node on the path with index v obtained by ServiceRelationship, and execute Step 5.17; In the first loop, when v = 0 and w = 0, since the path with index 0 of PathInterim record = "Hotel", OutNode = [Cinema, Wineshop, Plane], execute Step 5.17;

[0370] Step 5.17: Determine if n is less than the length of the list OutNode. If the condition is true, proceed to Step 5.18; otherwise, proceed to Step 5.26.

[0371] In the first loop, when w=0, v=0, and n=0, the length of the list OutNode is 3, and 0<3, so Step5.18 is executed;

[0372] In the first loop, when w=0, v=0, and n=3, the length of the list OutNode is 3, and 3! < 3, so Step 5.26 is executed;

[0373] Step 5.18: Initialize the variable Pvalue to store the service failure propagation probability corresponding to the service name with index n obtained using Propagation in the OutNode record. Then execute Step 5.19.

[0374] In the first loop, when w=0, v=0, n=0, since the OutNode records the service with index 0 as "Cinema", Pvalue=0.25, Step 5.19 is executed; Step 5.19: Determine if Pvalue is greater than Pthreshold. If the condition is true, execute Step 5.20; otherwise, execute Step 5.25.

[0375] In the first loop, when w=0, v=0, n=1, since OutNode.get(1) = "Wineshop" Pvalue = 0.46, Pthreshold = 0.4, 0.46>0.4, Step5.20 is executed;

[0376] In the first loop, when w=0, v=0, n=0, since OutNode.get(0) = "Cinema" Pvalue = 0.25, Pthreshold = 0.4, and 0.25! > 0.4, Step 5.25 is executed;

[0377] Step 5.20: Does the path with index v recorded by PathInterim contain the service name with index n recorded by OutNode? If the condition is not met, proceed to Step 5.21; otherwise, proceed to Step 5.25.

[0378] In the first loop, when w=0, v=0, and n=1, PathInterim records the path with index 0 as "Hotel", OutNode records the service with index 1 as "Wineshop", PathInterim records the path with index 0 as "Hotel", OutNode records the service with index 1 as "Wineshop", and PathInterim records the service with index 1 as "Wineshop", and Step5.21 is executed.

[0379] In the second loop, when w=0, v=2, and n=0, PathInterim records index 2 = "Hotel>0.50Plane", OutNode records index 0 for service = "Hotel", and the path with PathInterim record index 2 has a service with OutNode record index 0. Execute Step 5.25.

[0380] Step 5.21: Determine if z equals 0. If the condition is true, proceed to Step 5.22; otherwise, proceed to Step 5.24.

[0381] In the first loop, when w=0, v=0, n=1, z=0, and Step 5.22 is executed; in the first loop, when w=0, v=0, n=2, z=1, and Step 5.24 is executed.

[0382] Step 5.22: Replace the path with index v in the PathInterim record with the path with index v in the PathInterim record +">" + Pvalue + the service name with index n in the OutNode record, and then execute Step 5.23.

[0383] In the first loop, when w=0, v=0, and n=1, PathInterim records the path with index 0 as "Hotel>0.46Wineshop", and then executes Step5.23;

[0384] Step 5.23, z++, then execute Step 5.24;

[0385] Step 5.24: Add the path with index v to PathInterim record +">" + Pvalue + OutNode record for the service name with index n, and execute Step 5.23; In the first loop, when w=0, v=0, and n=2, add "Hotel>0.50Plane" to PathInterim and execute Step 5.23.

[0386] Step 5.25, n++, then execute Step 5.17;

[0387] Step 5.26, v++, execute Step 5.15;

[0388] Step 5.27: Check if Part 1 equals PathInterim. If the condition is true, proceed to Step 5.28; otherwise, proceed to Step 5.14.

[0389] In the first loop, when w=0, Part1=[Hotel], PathInterim=[Hotel>0.46Wineshop,Hotel>0.50Plane], and Step5.14 is executed;

[0390] In the third loop, when w=0, Part1=PathInterim=[Hotel>0.46Wineshop>0.50Plane,Hotel>0.50Plane] executes Step5.28;

[0391] Step 5.28: Add PathInterim to Path, initialize the list PathTerm to store temporary paths, add BreakService to PathTerm to record the service name with index w, and execute Step 5.29;

[0392] Add the list [Hotel>0.46Wineshop>0.50Plane,Hotel>0.50Plane] to the Path, then use PathTerm.add(“Hotel”) and execute Step 5.29;

[0393] Step 5.29: Initialize temporary variable s = 0, initialize list Path2, execute Part2..addAll(PathTerm) on Part2, and execute Step 5.30, where Path2.addAll(PathTerm) means adding list PathTerm to the list.

[0394] In the first loop, when w = 0, Part2.addAll(“Hotel”) is executed, and version 5.30 is executed;

[0395] Step 5.30: Is s less than the length of list Path2? If the condition is true, execute Step 5.31; otherwise, execute Step 5.42.

[0396] In the first loop, when w=0 and s=0, the length of list Path2 is 1, and 0<1, so Step5.31 is executed;

[0397] In the first loop, when w=0 and s=1, the length of list Path2 is 1, and 1! < 1, so Step5.42 is executed;

[0398] Step 5.31: Initialize temporary variable g = 0, initialize temporary variable f = 0, initialize list InNode to store the name of the running predecessor node service of the last node on the path with index s obtained by ServiceRelationship, and execute Step 5.32.

[0399] In the first loop, when w=0 and s=0, InNode=[Plane,Cinema,Train], and Step5.32 is executed;

[0400] Step 5.32: Determine if g is less than the length of the list InNode. If the condition is true, proceed to Step 5.33; otherwise, proceed to Step 5.41.

[0401] In the first loop, when w=0, s=0, g=0, the length of the list InNode is 3, 0<3, Step5.33;

[0402] In the first loop, when w=0, s=0, and g=3, the length of the list InNode is 3, and 3! < 3, so we go to Step 5.41;

[0403] Step 5.33: Initialize the variable Qvalue to store the service failure propagation probability corresponding to the service name with index g obtained using OtherService and Propagation in the InNode record. Then execute Step 5.34.

[0404] In the first loop, when w=0, s=0, and g=0, the probability of Plane being propagated by a fault is 0.50, so Step 5.34 is executed.

[0405] Step 5.34: Is Qvalue greater than Pthreshold? If the condition is true, proceed to Step 5.35; otherwise, proceed to Step 5.40.

[0406] In the first loop, when w=0, s=0, g=0, Qvalue=0.50, Pthreshold=0.4, 0.5>0.4, execute Step5.35;

[0407] In the first loop, when w=0, s=0, g=1, Qvalue=0.25, Pthreshold=0.4, and 0.25! > 0.4, execute Step 5.40;

[0408] Step 5.35: Does PathTerm.get(s) exist? If not, proceed to Step 5.36; otherwise, proceed to Step 5.40. Here, PathTerm.get(s) represents the path with index s recorded in PathTerm., and InNode.get(g) represents the service name with index g recorded in InNode.

[0409] In the first loop, w = 0, s = 0, g = 0, PathTerm.get(0) = "Hotel", InNode.get(0) = "Plane", and Step 5.36 is executed;

[0410] In the third loop, w=0, s=0, g=0, PathTerm.get(0) = "Hotel<0.50Plane<0.46Wineshop", InNode.get(0) = "Hotel", and Step 5.40 is executed;

[0411] Step 5.36: Is f equal to 0? If the condition is true, proceed to Step 5.37; otherwise, proceed to Step 5.39.

[0412] In the first loop, w=0, s=0, g=0, f=0, execute Step 5.37; in the second loop, w=0, s=0, g=2, f=1, execute Step 5.39.

[0413] Step 5.37: Add the path with index 's' to the PathTerm record, then add "<" to the Qvalue record and the service name with index 'g' to the InNode record. Then execute Step 5.38.

[0414] In the first loop, w=0, s=0, g=0, f=0, PathTerm.set(0, "Hotel<0.50Plane");

[0415] Step 5.38, f++, then execute Step 5.40;

[0416] Step 5.39: Add the path with index s to the PathTerm record, then add "<" + Qvalue + InNode to record the service name with index g. Execute Step 5.38. In the first loop, w = 0, s = 0, g = 2, f = 1, PathTerm.add(“Hotel<0.46Train”), and execute Step 5.38.

[0417] Step 5.40, g++, execute Step 5.32;

[0418] Step 5.41, s++, execute Step 5.30;

[0419] Step 5.42: Is Part 2 equal to PathTerm? If the condition is true, proceed to Step 5.43; otherwise, proceed to Step 5.29.

[0420] In the first loop, w = 0, Part2 = [Hotel], PathTerm = [Hotel < 0.50Plane, Hotel < 0.46Train], and Step 5.29 is executed;

[0421] In the third loop, w = 0, Part2 = PathTerm = [Hotel < 0.50Plane < 0.46Wineshop, Hotel < 0.46Train], execute Step 5.43;

[0422] Step 5.43: Add PathTerm to Path, then execute Step 5.44;

[0423] Add "Hotel<0.50Plane<0.46Wineshop,Hotel<0.46Train" to the Path, then execute Step 5.44;

[0424] Step 5.44, w++, execute Step 5.3;

[0425] Step 5.45: Output the list Path and end the execution;

[0426] The code `Path = [Hotel>0.46Wineshop>0.50Plane, Hotel>0.50Plane, Hotel<0.50Plane<0.46Wineshop, Hotel<0.46Train]` terminates execution. Taking "Hotel>0.46Wineshop>0.50Plane" as an example, this path propagates from Hotel to Wineshop and then to Plane. The probability of service failure propagation from Hotel to Wineshop is 0.46, and the probability of service failure propagation extending to Plane is 0.5. Similarly, taking "Hotel<0.50Plane<0.46Wineshop" as an example, this path propagates from Hotel to Plane and then to Wineshop. The probability of service failure propagation from Hotel to Plane is 0.5, and the probability of service failure propagation extending to Wineshop is 0.46.

[0427] The specific embodiments of the present invention have been described in detail above with reference to the accompanying drawings. However, the present invention is not limited to the above embodiments. Within the scope of knowledge possessed by those skilled in the art, various changes can be made without departing from the spirit of the present invention.

Claims

1. A method for determining service failure propagation paths in a cloud computing environment, characterized in that: The method comprises the following steps: extracting service running state invocation data in a target data set; establishing a service interaction graph according to the service running state invocation data; traversing the service interaction graph to establish a service relationship graph; outputting a service fault propagation path set according to the service relationship graph and the fault possibility of the service; the step of outputting the service fault propagation path set according to the service relationship graph and the fault possibility of the service comprises the following steps: reading the names of services in a running state according to the service relationship graph, obtaining historical normal data containing service running and service environment according to the service names, randomly extracting samples from the historical normal data containing service running and service environment, obtaining current monitored data containing service running and service environment according to the service names, calculating the fault possibility of the services represented by the service names by using hypothesis testing, comparing the fault possibility with a set threshold, determining the fault service name, recording the names of other services except the fault service name and the fault possibility of the services represented by the service names; calculating the similarity between the fault service and the services other than the fault service based on the service relationship graph according to the read fault service name, the names of other services except the fault service name and the fault possibility of the services represented by the service names; combining the similarity to calculate the service fault propagation probability; searching the service fault propagation path through the service relationship graph, the service fault propagation probability and a service fault propagation probability threshold, and outputting the service fault propagation path set.

2. The method of claim 1, wherein the method further comprises: The step of extracting the service running state invocation data in the target data set comprises the following steps:

3. The method of claim 1, wherein the method further comprises: reading a target data set monitored in a cloud environment, extracting service invocation data from the target data set, screening the service invocation data, obtaining service invocation data in a running state, and taking the service invocation data as service running state invocation data.

4. The method of claim 1, wherein the method further comprises: The step of establishing the service interaction graph according to the service running state invocation data comprises the following steps:

5. The method of claim 1, further comprising: obtaining service user names, service invocation numbers, service invocation states, service names according to the service running state invocation data, establishing a service interaction graph represented by an adjacency list, and listening to new service invocation data in real time to update the service interaction graph. The step of traversing the service interaction graph to establish a service relationship graph comprises the following steps: traversing the service interaction graph, counting the number of interaction connections of the same "service user name and service name" in the service interaction graph as the same service invocation frequency, and establishing a service relationship graph represented by an adjacency list according to the service user name, the service name and the same service invocation frequency; if the service invocation state of the same "service user name and service name" is a running state, the frequency is incremented by 1, otherwise the frequency is incremented by 0. The step of outputting the service fault propagation path set according to the service relationship graph and the fault possibility of the service comprises the following steps: Step5.1, read the list of service relationship ServiceRelationship, read the list of break service BreakService, read the list of service failure possibility ServiceExcept, read the list of other service names except break service OtherService, execute Step5.2; Step5.2, initialize an empty list Path for storing service failure propagation path, initialize temporary variable w=0, initialize temporary variable m=0, execute Step5.3; Step5.3, judge whether w is less than the length of list BreakService, if the condition is true, execute Step5.4, otherwise execute 5.45; Step5.4, initialize an empty list Correlation for storing service similarity, execute Step5.5; Step5.5, judge whether m is less than the length of list OtherService, if the condition is true, execute Step5.6, otherwise execute Step5.9; Step5.6, prune ServiceRelationship, execute Step5.7, wherein the pruning is to only keep the service relationship that is currently in the running state; Step5.7, Correlation adds the service similarity between the service corresponding to the service name of BreakService record index w and the service corresponding to the service name of OtherService record index m calculated by WSimRank algorithm, execute Step5.8; Step5.8, m++, execute Step5.9; Step5.9, initialize an empty list Propagation for storing the calculated service failure propagation probability, initialize temporary variable u=0, execute Step5.10; Step5.10, judge whether u is less than the length of list OtherService, if the condition is true, execute Step5.11, otherwise execute Step5.13; Step5.11, list Propagation adds the failure possibility of the service obtained by list Correlation record index u * list ServiceExcept record index u, execute Step5.12; Step5.12, u++, execute Step5.10; Step5.13, initialize service failure propagation probability threshold Pthreshold, initialize list PathInterim for storing temporary path, list PathInterim adds list BreakService record index w data, execute Step5.14; Step 5.14, initialize temporary variable v = 0, initialize list Part1, execute Part1.addAll(PathInterim) on Part1, execute Step 5.15; wherein Part1.addAll(PathInterim) means Part1 covers adding list PathInterim; Step 5.15, judge whether v is less than the length of list Part1, if the condition is true, execute Step 5.16, otherwise execute Step 5.27; Step 5.16, initialize temporary variable n = 0, initialize temporary variable z = 0, initialize list OutNode for storing the running successor service name of the last node on the path of PathInterim record index v obtained using ServiceRelationship, execute Step 5.17; Step 5.17, judge whether n is less than the length of list OutNode, if the condition is true, execute Step 5.18, otherwise execute Step 5.26; Step 5.18, initialize variable Pvalue for storing the service failure propagation probability corresponding to the service name of OutNode record index n obtained using Propagation, execute Step 5.19; Step 5.19, judge whether Pvalue is greater than Pthreshold, if the condition is true, execute Step 5.20, otherwise execute Step 5.25; Step 5.20, whether there is a service name of OutNode record index n in the path of PathInterim record index v, if the condition is not true, execute Step 5.21, otherwise execute Step 5.25; Step 5.21, judge whether z is equal to 0, if the condition is true, execute Step 5.22, otherwise execute 5.24; Step 5.22, replace the path of PathInterim record index v with the path of PathInterim record index v + ">" + Pvalue + the service name of OutNode record index n, execute Step 5.23; Step 5.23, z++, execute Step 5.25; Step 5.24, add PathInterim record index v path + ">" + Pvalue + OutNode record index n service name to PathInterim, execute Step 5.23; Step 5.25, n++, execute Step 5.17; Step 5.26, v++, execute Step 5.15; Step 5.27, whether Part1 is equal to PathInterim, if the condition is true, execute Step 5.28, otherwise execute Step 5.14; Step 5.28, Path adds PathInterim, initializes list PathTerm to store interim paths, PathTerm adds BreakService record index w of service name, executes Step 5.29; Step 5.29, initializes temporary variable s = 0, initializes list Path2, executes Part2.addAll(PathTerm) on Part2, executes Step 5.30, wherein Path2.addAll(PathTerm) indicates list cover adds list PathTerm; Step 5.30, whether s is less than the length of list Path2, if the condition is established, executes Step 5.31, otherwise executes Step 5.42; Step 5.31, initializes temporary variable g = 0, initializes temporary variable f = 0, initializes list InNode to store the running predecessor node service name of the last node on the path of PathTerm record index s obtained by using ServiceRelationship, executes Step 5.32; Step 5.32, whether g is less than the length of list InNode, if the condition is established, executes Step 5.33, otherwise executes Step 5.41; Step 5.33, initializes variable Qvalue to store the service failure propagation probability corresponding to the service name of InNode record index g obtained by using Propagation, executes Step 5.34; Step 5.34, whether Qvalue is greater than Pthreshold, if the condition is established, executes Step 5.35, otherwise executes Step 5.40; Step 5.35, whether PathTerm.get(s) exists in InNode.get(g), if the condition is not established, executes Step 5.36, otherwise executes Step 5.40; wherein PathTerm.get(s) indicates PathTerm record index s of path, InNode.get(g) indicates service name of InNode record index g; Step 5.36, whether f is equal to 0, if the condition is established, executes Step 5.37, otherwise executes Step 5.39; Step 5.37, PathTerm adds path "<" + Qvalue + InNode record index g of service name of PathTerm record index s, executes Step 5.38; Step 5.38, f++, executes Step 5.40; Step 5.39, PathTerm adds path "<" + Qvalue + InNode record index g of service name of PathTerm record index s, executes Step 5.38; Step 5.40, g++, executes Step 5.32; Step 5.41, s++, perform Step 5.30; Step 5.42, check if Part2 is equal to PathTerm, if true, perform Step 5.43, otherwise perform Step 5.29; Step 5.43, Path is added PathTerm, perform Step 5.44; Step 5.44, w++, perform Step 5.3; Step 5.45, output list Path, end execution.

6. The method of claim 5, wherein the method further comprises: The WSimRank algorithm is specifically: wherein, represents the service similarity of respectively represents service t, b, and C is a loss coefficient, represents the product of the service similarity of represents the total number of neighbor nodes of service t, represents the total number of neighbor nodes of service b, represents the i-th neighbor node of service t, represents the j-th neighbor node of service b; represents the i-th neighbor node of service t and the normalized weight of service t, represents the j-th neighbor node of service b and the normalized weight of service b, represents the service similarity of represents the i-th neighbor node of service t and the weight of service t, represents the sum of the i-th neighbor node of service t and the weight of service t; represents the interaction frequency of the i-th neighbor node of service t and service t in the service relationship graph, represents the running frequency of the i-th neighbor node of service t in the service relationship graph, represents the running frequency of service t in the service relationship graph, represents the total running frequency contained in the service relationship graph; service t represents the service with the service name t in the service relationship graph, and service b represents the service with the service name b in the service relationship graph.

7. A cloud computing environment service fault propagation path determination device, characterized by comprising: comprising: an extraction module configured to extract service running state invocation data in a target data set; a first establishment module configured to establish a service interaction graph according to the service running state invocation data; a second establishment module configured to traverse the service interaction graph and establish a service relationship graph; an output module configured to output a service fault propagation path set according to the service relationship graph and a service fault likelihood; read the names of services in a running state according to the service relationship graph, obtain historical normal data containing service running and service environment according to the service names, randomly extract samples from the historical normal data containing service running and service environment, obtain current monitored data containing service running and service environment according to the service names, calculate the fault likelihood of each service represented by the service name by using hypothesis testing, compare the fault likelihood with a set threshold, determine the fault service name, record other service names except the fault service name and the fault likelihood of the service represented by the service name; calculate the similarity between the fault service and the services other than the fault service based on the service relationship graph according to the read fault service name, the other service names except the fault service name and the fault likelihood of the service represented by the service name, calculate the service fault propagation probability in combination with the similarity, search for the service fault propagation path through the service relationship graph, the service fault propagation probability and a service fault propagation probability threshold, and output the service fault propagation path set.

8. A processor, comprising: The processor is configured to perform the method of any one of claims 1-6.

9. A computer-readable storage medium comprising a stored program, characterized in that: The program, when executed by the processor, causes the processor to implement the method of any one of claims 1-6.

Images