Test result generation method of hyper-converged architecture and product
In the high availability test of the hyperconverged architecture system, the target test node is selected according to the test dimension scores and weights of each converged node, and the closing order is determined based on the process dependency relationship, and the problems of uncertain node selection and low cost in existing tests are solved, and more efficient and accurate test results are achieved.
Patent Information
- Application Number
- CN202411744386.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-11-30
- Publication Date
- 2025-04-15
AI Technical Summary
In the high availability test of existing hyperconverged architecture systems, uncertain node selection results in inaccurate test results, and the test method of traversing all nodes is cost-effective.
By obtaining the scores and weights of each fusion node on each test dimension, selecting a calibrated number of target test nodes, and determining the closing order based on the dependencies between processes, generating test results.
Improves testing efficiency and accuracy, reduces testing costs, and can more effectively expose problems with hyperconverged architectures.
Smart Images
Figure CN119829422A_ABST
Abstract
Description
Technical Field
[0001] The embodiments of the present application relate to the technical field of system testing, and in particular, to a method and product for generating test results of a hyper-converged architecture. Background Art
[0002] Hyper-converged architecture is an information infrastructure that integrates virtual computing resources and storage devices. In a hyper-converged architecture environment, the same set of unit devices not only has resources and technologies such as computing, storage, network and server virtualization, but also multiple sets of unit devices can be aggregated through the network to achieve modular seamless horizontal expansion and form a unified resource pool; hyper-converged architecture can expand the computing performance and storage capacity of the entire cluster by increasing the number of nodes in the cluster, and can also provide service high availability and data protection capabilities through data replication and backup between nodes in the cluster. Currently, more and more systems are adopting hyper-converged architecture.
[0003] After deploying a hyper-converged architecture system for a customer, in order to ensure the high availability of the hyper-converged architecture system, a high-availability test can be performed on the hyper-converged architecture system. However, in the current high-availability test of the hyper-converged architecture system, a test method of randomly selecting fusion nodes for shutdown is mostly adopted. The selection of fusion nodes for the test is uncertain, which may lead to inaccurate test results. If the test method of traversing all fusion nodes for shutdown is used, the test cost will be high and the test efficiency will be reduced. Summary of the invention
[0004] In order to solve the above problems, the embodiments of the present application provide a test result generation method and product for a hyper-converged architecture.
[0005] In a first aspect, an embodiment of the present application provides a method for generating test results of a hyper-converged architecture, the method comprising: Obtain the score of each fusion node in the hyper-converged architecture in each test dimension, where any test dimension represents the target capability of the hyper-converged architecture in the current application scenario; Select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension. The weight of the test dimension is used to characterize the importance of any test dimension in the current application scenario. A process test strategy is executed on any target test node to generate a test result of the hyper-converged architecture, wherein the process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and to test the target test node.
[0006] Optionally, according to the score of each fusion node in each test dimension and the weight of each test dimension, a calibrated number of target test nodes is selected, including: According to the scores of each fusion node in each test dimension, the node with the highest score and the node with the lowest score in each test dimension are selected to form a candidate node set; Deduplication of the candidate node set; In the set of candidate nodes after deduplication, the target test node is selected according to the score of each fusion node in each test dimension and the weight of each test dimension.
[0007] Optionally, in the candidate node set after deduplication, a target test node is selected according to the score of each fusion node in each test dimension and the weight of each test dimension, including: For any fused node in the candidate node set after deduplication, the total evaluation score corresponding to the fused node is obtained by weighted summation according to the score of the fused node in each test dimension and the weight of each test dimension; The total evaluation score corresponding to each fusion node is used as the selection weight, and the NumPy library function np.random.choice function is used to determine the calibrated number of target test nodes in the candidate node set.
[0008] Optionally, executing a process test strategy on any target test node to generate a test result of the hyper-converged architecture includes: Determine a process graph corresponding to any target test node according to the dependency relationship between multiple processes in any target test node, wherein a node in the process graph corresponds to any process, and an edge in the process graph corresponds to a dependency relationship; Determining a closing order of the multiple processes in the target test node according to the process graph; The processes are closed in sequence according to the closing order of the multiple processes, the target test node is restarted, the hyper-converged architecture is tested according to the preset test case, and the test result of the hyper-converged architecture is obtained.
[0009] Optionally, determining the closing order of the multiple processes in the target test node according to the process graph includes: Create an in-degree dictionary, an intermediate queue and a result queue respectively, wherein the key of the in-degree dictionary is the process name, the key value is the in-degree of the process, and the in-degree represents the number of dependencies corresponding to any process; According to the process graph, determining the in-degree of any process in the initialized in-degree dictionary; Based on the in-degree dictionary, the intermediate queue and the result queue, a loop sub-strategy is executed to determine the closing order of the multiple processes, and the loop sub-strategy is used to determine the closing order of the multiple processes according to the order of dependency quantity from high to low.
[0010] Optionally, executing a loop sub-strategy to determine the closing order of the multiple processes includes: Execute the loop sub-strategy, including: Adding the process whose current in-degree in the in-degree dictionary is 0 to the intermediate queue from the tail of the intermediate queue; Remove the process at the head of the current intermediate queue and add it to the result queue from the tail of the result queue, and reduce the in-degree of any process in the in-degree dictionary that depends on the process by 1; When the intermediate queue is empty, the loop sub-strategy is exited, and the multiple processes in the result queue are sorted from the end to the head as the closing order of the multiple processes.
[0011] In a second aspect, an embodiment of the present application provides a test result generating device for a hyper-converged architecture, the device comprising: An acquisition module is used to obtain the score of each fusion node in the hyper-converged architecture in each test dimension, and any test dimension represents the target capability of the hyper-converged architecture in the current application scenario; The target test node determination module is used to select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension. The weight of the test dimension is used to characterize the importance of any test dimension in the current application scenario. A test module is used to execute a process test strategy on any target test node to generate a test result of the hyper-converged architecture. The process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and to test the target test node.
[0012] In a third aspect, an embodiment of the present application provides a computer device, comprising: at least one processor, and a memory, wherein the memory stores a computer program that can be run on the processor, wherein when the processor executes the computer program, the test result generating method of the hyper-converged architecture described in the first aspect of the embodiment is executed.
[0013] In a fourth aspect, an embodiment of the present application provides a non-volatile readable storage medium, wherein the non-volatile readable storage medium stores a computer program, wherein when the computer program is executed by a processor, the test result generating method of the hyper-converged architecture described in the first aspect of the embodiment is executed.
[0014] In a fifth aspect, an embodiment of the present application provides a computer program product, including a computer program / instruction, which, when executed by a processor, implements the method for generating test results of a hyper-converged architecture described in the first aspect of the embodiment.
[0015] Beneficial effects: Obtain the scores of each fusion node in the hyper-converged architecture in each test dimension, where any test dimension characterizes the target capability of the hyper-converged architecture in the current application scenario; select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weights of each test dimension, where the weights of the test dimensions are used to characterize the importance of any test dimension in the current application scenario; execute a process test strategy on any target test node to generate a test result of the hyper-converged architecture, where the process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and test the target test node.
[0016] In this method, when testing the hyper-converged architecture, each test dimension is determined according to the target capability of the hyper-converged architecture in the current application scenario, and then different weights are assigned according to the importance of each test dimension in the current application scenario. When selecting the target test node, the test node selected is a more representative node in the current application scenario of the hyper-converged architecture according to the size of the score of each fusion node in each test dimension and the weight of each test dimension. The shutdown order of multiple processes is determined according to the number of dependencies between the processes of the target test node. Compared with randomly ending any process of the node, it is easier to expose the problems of the hyper-converged architecture, so that the target test node is determined in combination with the application scenario of the hyper-converged architecture, and the shutdown order of multiple processes is determined according to the dependency relationship between the processes of the node, so that the test result is more accurate. BRIEF DESCRIPTION OF THE DRAWINGS
[0017] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for use in the description of the embodiments of the present application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.
[0018] Figure 1 It is a flowchart of the steps of a method for generating test results of a hyper-converged architecture proposed in an embodiment of the present application; Figure 2 is a flowchart of steps for determining a target test node proposed in an embodiment of the present application; Figure 3 is a flowchart of the steps of executing a process test strategy provided by an embodiment of the present application; Figure 4 It is a schematic diagram of a process diagram proposed in an embodiment of the present application; Figure 5 It is a functional module diagram of a test result generating device of a hyper-converged architecture proposed in an embodiment of the present application; Figure 6 is a schematic diagram of a computer device provided by an embodiment of the present application; Figure 7 is a schematic diagram of a non-volatile readable storage medium proposed in an embodiment of the present application; Figure 8 It is a schematic diagram of a computer program product proposed in one embodiment of the present application. DETAILED DESCRIPTION
[0019] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.
[0020] Hyper-converged architecture is an information infrastructure that integrates virtual computing resources and storage devices. In a hyper-converged architecture environment, the same set of unit devices not only has resources and technologies such as computing, storage, network and server virtualization, but multiple sets of unit devices can be aggregated through the network to achieve modular seamless horizontal expansion and form a unified resource pool.
[0021] Hyper-converged architecture can expand the computing performance and storage capacity of the entire cluster by increasing the number of nodes in the cluster. It can also provide high availability and data protection capabilities through data replication and backup between nodes in the cluster. Currently, more and more systems are adopting hyper-converged architecture.
[0022] After deploying a hyper-converged architecture system for a customer, in order to ensure the high availability of the hyper-converged architecture system, a high availability test can be performed on the hyper-converged architecture system.
[0023] However, in the current high-availability testing of hyper-converged architecture systems, the test method mostly adopts the method of randomly selecting fusion nodes for shutdown. There is uncertainty in the selection of fusion nodes for test, which may lead to inaccurate test results. If the test method of traversing all fusion nodes for shutdown is used, it will lead to high test costs and reduced test efficiency.
[0024] Therefore, in order to improve test efficiency and obtain more accurate test results, an embodiment of the present application provides a test result generation method for a hyper-converged architecture.
[0025] Reference Figure 1 , shows a flowchart of a method for generating test results of a hyper-converged architecture in an embodiment of the present application, and the method may include the following steps: S101: Obtain the score of each fusion node in the hyper-converged architecture in each test dimension, where any test dimension represents the target capability of the hyper-converged architecture in the current application scenario.
[0026] The hyper-converged architecture has different capabilities in different application scenarios. For example, the capabilities include hyper-converged product hardware-related capabilities, virtual machine-related capabilities, container-related capabilities, data service-related capabilities, artificial intelligence-related functions, system management-related capabilities, and proprietary and third-party software stack integration capabilities.
[0027] During the actual implementation process, you can refer to the current third-party evaluation report documents on the weights of various capabilities of the hyper-converged architecture in different scenarios, and pre-set the target capabilities of the hyper-converged architecture to be tested in the current application scenario. For example, multiple capabilities in the evaluation report documents whose weights of various capabilities in the current application scenario are greater than the preset weight threshold can be used as the target capabilities of the hyper-converged architecture in the current application scenario.
[0028] For example, suppose that in a third-party evaluation report document on the weights of various capabilities of a hyper-converged architecture in different scenarios, in application scenario A, the weights of the hyper-converged product hardware-related capabilities of the hyper-converged architecture are 9%, virtual machine-related capabilities are 15%, container-related capabilities are 8%, data service-related capabilities are 12%, artificial intelligence-related functions are 9%, and proprietary and third-party software stack integration capabilities are 6%...; if the current application scenario of the hyper-converged architecture to be tested is also application scenario A, and the preset weight threshold is 7%, then multiple capabilities with weights greater than 7%, namely, the weights of the hyper-converged product hardware-related capabilities, virtual machine-related capabilities, container-related capabilities, data service-related capabilities, and artificial intelligence-related functions can be selected as the target capabilities of the hyper-converged architecture in the current application scenario, and each target capability is further used as a test dimension of the testing process, and corresponding weights are reallocated to all test dimensions. The weights of the test dimensions are used to characterize the importance of any test dimension in the current application scenario, and the sum of the weights of all test dimensions is 1.
[0029] For example, the multiple test dimensions are recorded as D1, D2...Dn respectively, and the weights corresponding to the multiple test dimensions are W1, W2...Wn, and there are n test dimensions in total.
[0030] Then, based on the performance of the hyper-converged architecture, the score of each fusion node in each test dimension is manually set. During the manual setting, the score of each fusion node in each test dimension can be set and stored based on the design instructions and application experience of the hyper-converged architecture.
[0031] When it is necessary to test the hyper-converged architecture in the current application scenario, first obtain the score of each fusion node in the hyper-converged architecture in each test dimension.
[0032] For example, the fusion nodes can be recorded as N1, N2...Ni, with a total of i fusion nodes. The score of any fusion node Ni on the test dimension D1 is recorded as Si-1, and the score of any fusion node Ni on the test dimension Dn is recorded as Si-n.
[0033] S102: Select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension.
[0034] Reference Figure 2 , shows a flowchart of the steps of determining the target test nodes in an embodiment of the present application. In a feasible implementation manner, according to the size of the score of each fusion node in each test dimension and the weight of each test dimension, the process of selecting a calibrated number of target test nodes may include the following steps: A1: According to the scores of each fusion node in each test dimension, the node with the highest score and the node with the lowest score in each test dimension are selected to form a candidate node set.
[0035] That is, for any test dimension Dj, according to the score of each node on the test dimension, the node with the highest score and the node with the lowest score on the test dimension are selected, as shown in the following formula: Minj=Min(Si-1……Si-j) Maxj=Max(Si-1……Si-j) After selection is made on each test dimension, the selected nodes are used as a candidate node set.
[0036] A2: De-duplicate the candidate node set.
[0037] Since there may be a situation where any fused node Ni has the highest score on the test dimension D1, but the lowest score on the test dimension D2, any fused node may appear multiple times in the candidate node set. Therefore, the candidate node set is deduplicated, and any fused node in the deduplicated candidate node set is unique.
[0038] By selecting the fusion nodes with the highest and lowest scores in any test dimension as candidate nodes, the candidate nodes are the nodes with the best and worst performance in any test dimension, that is, the selected nodes are representative nodes.
[0039] A3: In the set of candidate nodes after deduplication, the target test node is selected based on the score of each fusion node in each test dimension and the weight of each test dimension.
[0040] Specifically, first, for any fused node in the candidate node set after deduplication, a weighted sum is performed according to the score of the fused node in each test dimension and the weight of each test dimension to obtain the total evaluation score corresponding to the fused node.
[0041] That is, the calculation formula for the total evaluation score Ci corresponding to the fused node Ni in the candidate node set after deduplication is as follows: Ci=Si-1×W1+Si-2×W2+……Si-n×Wn Next, the total evaluation score corresponding to each fusion node is used as the selection weight, and the NumPy library function np.random.choice function is used to determine the calibrated number of target test nodes in the candidate node set. By using the total evaluation score as the selection weight for random selection in the candidate node set, the convenience of random selection of nodes can be maintained. Compared with the test method that covers all fusion nodes, the test cost can be reduced, and the selected target test nodes can also be made more representative nodes in the current application environment.
[0042] In the actual implementation process, the calibration number of the target test nodes can be set according to the needs of the actual application. For example, the calibration number can be set to 2, that is, 2 target test nodes are finally selected for high availability testing of the hyper-converged architecture.
[0043] S103: Execute a process test strategy on any target test node to generate a test result of the hyper-converged architecture, wherein the process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and test the target test node.
[0044] Reference Figure 3 , shows a flowchart of the steps of executing the process test strategy in an embodiment of the present application. In a feasible implementation manner, the process of executing the process test strategy on any target test node and generating the test result of the hyper-converged architecture includes the following steps: B1: According to the dependency relationship between multiple processes in any target test node, determine the process graph corresponding to the target test node.
[0045] The nodes in the process graph correspond to any process, and the edges in the process graph correspond to dependency relationships. Assuming that the premise for starting process B is that process A has been started, it indicates that process B has a dependency on process A. Then, the edge between the node of process A and the node of process B in the process graph points from process A to process B, indicating that process B is started only after process A is started.
[0046] B2: Determine the closing order of the multiple processes in the target test node according to the process diagram.
[0047] Specifically, when determining the closing order of the multiple processes in the target test node, first create an in-degree dictionary, an intermediate queue and a result queue respectively, wherein the key of the in-degree dictionary is the process name, the key value is the in-degree of the process, and the in-degree represents the number of dependencies corresponding to any process.
[0048] Assuming that the startup of process A does not depend on any other process, the number of dependencies of process A is 0, that is, the in-degree of process A is 0; reflected in the process graph, the more times any process node is pointed to by edges, the greater the in-degree.
[0049] Then, according to the process graph, the in-degree of any process in the initialized in-degree dictionary is determined, that is, the initial in-degree dictionary is first determined according to the dependency relationship between processes in the target test node during normal operation.
[0050] Next, based on the in-degree dictionary, the intermediate queue and the result queue, a loop sub-strategy is executed to determine a closing order of the multiple processes.
[0051] Specifically, the process of executing the loop sub-strategy includes: adding the process whose current in-degree is 0 in the in-degree dictionary from the tail of the intermediate queue to the intermediate queue; removing the process at the head of the current intermediate queue, and adding it to the result queue from the tail of the result queue, and reducing the in-degree corresponding to any process that depends on the process in the in-degree dictionary by 1.
[0052] The sub-strategy is executed cyclically until the intermediate queue is empty, then the cyclic sub-strategy is exited, and the multiple processes in the result queue are sorted from the end to the head as the closing order of the multiple processes.
[0053] The loop sub-strategy is used to determine the shutdown order of the multiple processes according to the order of dependency number from high to low, that is, during the test, the process with the largest in-degree, that is, the process with the highest dependency number, is closed first to test whether the hyper-converged architecture has high availability after the process with the highest dependency number is closed.
[0054] B3: shut down each process in turn according to the shutdown order of the multiple processes, restart the target test node, test the hyper-converged architecture according to a preset test case, and obtain a test result of the hyper-converged architecture.
[0055] After determining the process shutdown order corresponding to any target test node, multiple processes of the target test node are closed in sequence according to the shutdown order, and then the target test node is restarted. The hyper-converged architecture can be tested with preset test cases. The preset test cases include whether the virtual machine can be turned on and whether the hard disk can be mounted. The preset test cases can be set according to the actual application needs. No testing is performed in this embodiment.
[0056] In a feasible implementation manner, a hyper-converged architecture consisting of four fusion nodes is taken as an example to introduce the method provided in this embodiment.
[0057] The four fusion nodes of the hyper-converged architecture are N1, N2, N3, and N4; the hyper-converged architecture has five test dimensions in the current application scenario, namely, hyper-converged product hardware-related capabilities D1, virtual machine-related capabilities D2, container-related capabilities D3, data service-related capabilities D4, and artificial intelligence-related functions D5, with corresponding weights W1=0.1, W2=0.3, W3=0.4, W4=0.15, and W5=0.05.
[0058] S1: Obtain the score of each fusion node in the hyper-converged architecture in each test dimension.
[0059] Specifically, the scores of the four fusion nodes on the five test dimensions are shown in Table 1.
[0060] Table 1 Score table of each fusion node in each test dimension
[0061] S2: According to the scores of each fusion node in each test dimension, select the node with the highest score and the node with the lowest score in each test dimension to form a candidate node set.
[0062] Taking the scores of the four nodes in the test dimension D1 as an example, the candidate nodes corresponding to the test dimension D1 are determined as follows: Min1=Min(0.7,0.6,0.5,0.9)=N3 Max1=Max(0.7,0.6,0.5,0.9)=N4 Similarly, the candidate nodes corresponding to each test dimension are determined as shown in Table 2.
[0063] Table 2 Candidate nodes corresponding to each test dimension
[0064] That is, the candidate node set is: Set={N3, N4, N4, N3, N3, N2, N2, N4, N3, N4} S3: De-duplicate the candidate node set.
[0065] The obtained candidate node set after deduplication is {N2, N3, N4}.
[0066] S4: For any fused node in the candidate node set after deduplication, a total evaluation score corresponding to the fused node is obtained by weighted summing according to the scores of the fused node in each test dimension and the weights of each test dimension.
[0067] Based on: W1=0.1, W2=0.3, W3=0.4, W4=0.15, W5=0.05; Specifically, the total evaluation score C2 corresponding to the fusion node N2 is calculated as: C2=0.6×0.1+0.8×0.3+0.9×0.4+0.6×0.15+0.3×0.05=0.765 The calculation of the total evaluation score C3 corresponding to the fusion node N3 is: C3=0.5×0.1+0.9×0.3+0.3×0.4+0.7×0.15+0.2×0.05=0.555 The calculation of the total evaluation score C4 corresponding to the fusion node N4 is: C4=0.9×0.1+0.3×0.3+0.6×0.4+0.8×0.15+0.6×0.05=0.57.
[0068] S5: Taking the total evaluation score corresponding to each fusion node as the selection weight, using the NumPy library function np.random.choice function to determine the calibrated number of target test nodes in the candidate node set.
[0069] That is, the selection weight of fusion node N2 is 0.765, the selection weight of fusion node N3 is 0.555, and the selection weight of fusion node N4 is 0.57. The NumPy library function np.random.choice function is used to randomly select from the candidate node set {N2, N3, N4} after deduplication, and two target test nodes are selected as fusion node N2 and fusion node N4.
[0070] The fusion node N2 and the fusion node N4 are tested respectively. In this embodiment, the test process of the fusion node N2 is taken as an example for description.
[0071] S6: Determine a process graph corresponding to any target test node according to the dependency relationship between multiple processes in the target test node.
[0072] Taking the fusion node N2 as an example, the fusion node N2 includes 7 processes, namely process A, process B, process C, process D, process E, process F and process G.
[0073] Reference Figure 4 , shows a schematic diagram of a process graph provided in an embodiment of the present application, where the process graph is obtained based on the dependency relationship of the seven processes of the fusion node N2. For example, process A does not depend on other processes, so there is no edge pointing to process A; but process C, process D, and process G all depend on process A. Therefore, the direction of the edge from the node of process A to process C in the process graph is from process A to process C.
[0074] S7: Determine the closing order of the multiple processes in the target test node according to the process diagram.
[0075] First, create the in-degree dictionary D, intermediate queue Q and result queue L.
[0076] Next, according to the process graph, the in-degree of any process in the initialized in-degree dictionary is determined, and the obtained initialized in-degree dictionary is: D={'A': 0, 'B': 1, 'C': 2, 'D': 1, 'E': 2, 'F': 1, 'G': 2}.
[0077] Then, the process of the loop sub-strategy is executed, that is, the process with the current in-degree of 0 in the in-degree dictionary is added from the tail of the intermediate queue to the intermediate queue; the process at the head of the current intermediate queue is removed and added to the result queue from the tail of the result queue, and the in-degree corresponding to any process that depends on the process in the in-degree dictionary is reduced by 1.
[0078] For example, based on the initialized in-degree dictionary, the process with in-degree 0 is process A. Process A is added to the intermediate queue from the tail of the intermediate queue. At this time, the intermediate queue Q={'A'}, and the result queue L=[ ].
[0079] Then, the process at the head of the current intermediate queue is removed, and added to the result queue from the tail of the result queue. At this time, the intermediate queue Q={}, and the result queue L=['A'].
[0080] Then the in-degree of the processes that depend on process A in the in-degree dictionary D is reduced by 1. The processes that depend on process A are process C, process D and process G. The updated in-degree dictionary is: D={'A': 0, 'B': 1, 'C': 1, 'D': 0, 'E': 2, 'F': 1, 'G': 1} In the next cycle, they are updated as follows: Intermediate queue Q = {'D'}; Intermediate queue Q={}, result queue L=['A', 'D']; D={'A': 0, 'B': 0, 'C': 1, 'D': 0, 'E': 1, 'F': 1, 'G': 1}.
[0081] In the next cycle, they are updated as follows: Intermediate queue Q = {'B'}; Intermediate queue Q={}, result queue L=['A', 'D', 'B']; D={'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 1, 'F': 1, 'G': 0}; In the next cycle, they are updated as follows: Intermediate queue Q = {'C', 'G'}; Intermediate queue Q={'G'}, result queue L=['A', 'D', 'B', 'C']; D={'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 1, 'F': 1, 'G': 0}; Cycle in sequence until the middle queue is empty, then exit the cyclic sub-strategy, and finally get Result queue L = ['A', 'D', 'B', 'C', 'G', 'F', 'E']; The multiple processes in the result queue L are sorted from the end to the head as the closing order of the multiple processes, that is, the closing order is EFDCBDA.
[0082] S8: According to the shutdown order EFGCBDA, multiple processes of the fusion node N2 are shut down in sequence, and then the fusion node N2 is restarted. The hyper-converged architecture can be tested with a preset test case to obtain a test result corresponding to the fusion node N2.
[0083] At present, in the common single-node shutdown high-availability test of fusion nodes, the shutdown node selection is mostly random selection of nodes, or traversal of nodes; random selection of shutdown nodes is simple and fast, but there is a risk of test omissions, and traversal of shutdown nodes, although it can cover all scenarios, is time-consuming and labor-intensive; compared with the current testing method, this method combines the application scenarios of the hyper-converged architecture, determines different test dimensions and corresponding weights, and then selects the test node according to the score of each fusion node in each dimension. The candidate node set is then selected based on the node score in each test dimension and the weight of the test dimension, and the more representative nodes in the current application scenario are randomly selected for testing. While ensuring the randomness of shutdown node selection to ensure convenience, it can also improve coverage, thereby obtaining more accurate test results.
[0084] Moreover, currently, when shutting down a single node for high availability testing, most of the tests are performed by testers through the shutdown soft command. Since shutdown kills processes in random order, there are many uncertainties. This method terminates processes in order according to the dependencies between processes, rather than randomly terminating them. This method is more conducive to exposing problems with the hyper-converged architecture and obtaining more accurate test results.
[0085] Reference Figure 5 , shows a functional module diagram of a test result generating device of a hyper-converged architecture provided in an embodiment of the present application, the device comprising: An acquisition module 100 is used to obtain the score of each fusion node in the hyper-converged architecture in each test dimension, where any test dimension represents the target capability of the hyper-converged architecture in the current application scenario; The target test node determination module 200 is used to select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension, wherein the weight of each test dimension is used to characterize the importance of any test dimension in the current application scenario; The test module 300 is used to execute a process test strategy on any target test node to generate a test result of the hyper-converged architecture. The process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and to test the target test node.
[0086] Optionally, the target test node determination module includes: A candidate test node determination unit, configured to select the node with the highest score and the node with the lowest score in each test dimension according to the score of each fusion node in each test dimension, to form a candidate node set; A deduplication unit, used for deduplicating the candidate node set; The target test node determination unit is used to select the target test node from the candidate node set after deduplication according to the score of each fusion node in each test dimension and the weight of each test dimension.
[0087] Optionally, the target test node determination unit includes: The total evaluation score calculation unit is used to obtain the total evaluation score corresponding to any fused node in the candidate node set after deduplication by weighted summing up the scores of the fused node in each test dimension and the weights of each test dimension; The random selection unit is used to use the total evaluation score corresponding to each fusion node as a selection weight, and use the NumPy library function np.random.choice function to determine the calibrated number of target test nodes in the candidate node set.
[0088] Optionally, the test module includes: A process graph determining unit, configured to determine a process graph corresponding to any target test node according to dependencies between multiple processes in the target test node, wherein a node in the process graph corresponds to any process, and an edge in the process graph corresponds to a dependency relationship; A sequence determination unit, configured to determine a closing sequence of the plurality of processes in the target test node according to the process graph; The testing unit is used to close each process in turn according to the closing order of the multiple processes, restart the target test node, test the hyper-converged architecture according to the preset test case, and obtain the test result of the hyper-converged architecture.
[0089] Optionally, the sequence determination unit includes: A creation unit, used to create an in-degree dictionary, an intermediate queue and a result queue respectively, wherein the key of the in-degree dictionary is the process name, the key value is the in-degree of the process, and the in-degree represents the number of dependencies corresponding to any process; an initialization unit, configured to determine the in-degree of any process in the initialized in-degree dictionary according to the process graph; A loop unit is used to execute a loop sub-strategy based on the in-degree dictionary, the intermediate queue and the result queue to determine the closing order of the multiple processes, and the loop sub-strategy is used to determine the closing order of the multiple processes according to the order of dependency quantity from high to low.
[0090] Optionally, the circulation unit comprises: The first unit is used to execute the loop sub-strategy, including: adding the process with the current in-degree of 0 in the in-degree dictionary from the tail of the intermediate queue to the intermediate queue; removing the process at the head of the current intermediate queue and adding it to the result queue from the tail of the result queue, and reducing the in-degree corresponding to any process in the in-degree dictionary that depends on the process by 1; The second unit is used to exit the loop sub-strategy until the intermediate queue is empty, and to sort the multiple processes in the result queue from the end to the head as the closing order of the multiple processes.
[0091] Reference Figure 6 , shows a schematic diagram of a computer device provided in an embodiment of the present application, including: at least one processor 601, and a memory 602, wherein the memory 602 stores a computer program that can be run on the processor 601, wherein the processor 601 executes the test result generation method of the hyper-converged architecture described in the embodiment when executing the computer program.
[0092] Reference Figure 7 , shows a schematic diagram of a non-volatile readable storage medium provided in an embodiment of the present application, wherein the non-volatile readable storage medium 700 stores a computer program 701, wherein when the computer program 701 is executed by a processor, the test result generating method of the hyper-converged architecture described in the embodiment is executed.
[0093] Reference Figure 8 , shows a schematic diagram of a computer program product provided in an embodiment of the present application, wherein the computer program product 800 includes a computer program / instruction 801, which, when executed by a processor, implements the test result generating method for the hyper-converged architecture described in the embodiment.
[0094] The various embodiments in this specification are described in a progressive manner, and each embodiment focuses on the differences from other embodiments. The same or similar parts between the various embodiments can be referenced to each other.
[0095] It should be understood by those skilled in the art that the embodiments of the present application can be provided as methods, devices or computer program products. Therefore, the embodiments of the present application can be in the form of a complete hardware embodiment, a complete software embodiment or an embodiment combining software and hardware. Moreover, the embodiments of the present application can be in the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.
[0096] The embodiments of the present application are described with reference to the flowcharts and / or block diagrams of the methods, terminal devices (systems) and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor or other programmable data processing terminal device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing terminal device generate instructions for implementing the processes in the flowchart. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.
[0097] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing terminal device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a manufactured product including an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.
[0098] These computer program instructions can also be loaded onto a computer or other programmable data processing terminal device so that a series of operating steps are executed on the computer or other programmable terminal device to produce a computer-implemented process, thereby providing instructions for executing on the computer or other programmable terminal device to implement the process. Figure 1 A process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.
[0099] Although the preferred embodiments of the present application have been described, those skilled in the art may make additional changes and modifications to these embodiments once they have learned the basic creative concept. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the embodiments of the present application.
[0100] Finally, it should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprises" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or terminal device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or terminal device. In the absence of further restrictions, the elements defined by the sentence "including one..." do not exclude the existence of other identical elements in the process, method, article or terminal device including the elements.
[0101] Specific examples are used herein to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea. At the same time, for those skilled in the art, according to the idea of the present application, there will be changes in the specific implementation methods and application scope. In summary, the content of this specification should not be understood as a limitation on the present application.
Claims
1. A method for generating test results of a hyper-converged architecture, characterized in that: The method comprises: Obtain the score of each fusion node in the hyper-converged architecture in each test dimension, where any test dimension represents the target capability of the hyper-converged architecture in the current application scenario; Select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension. The weight of the test dimension is used to characterize the importance of any test dimension in the current application scenario. A process test strategy is executed on any target test node to generate a test result of the hyper-converged architecture, wherein the process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and to test the target test node.
2. The method according to claim 1, characterized in that According to the score of each fusion node in each test dimension and the weight of each test dimension, select a calibrated number of target test nodes, including: According to the scores of each fusion node in each test dimension, the node with the highest score and the node with the lowest score in each test dimension are selected to form a candidate node set; Deduplication of the candidate node set; In the set of candidate nodes after deduplication, the target test node is selected according to the score of each fusion node in each test dimension and the weight of each test dimension.
3. The method according to claim 2, characterized in that In the candidate node set after deduplication, the target test node is selected according to the score of each fusion node in each test dimension and the weight of each test dimension, including: For any fused node in the candidate node set after deduplication, the total evaluation score corresponding to the fused node is obtained by weighted summation according to the score of the fused node in each test dimension and the weight of each test dimension; The total evaluation score corresponding to each fusion node is used as the selection weight, and the NumPy library function np.random.choice function is used to determine the calibrated number of target test nodes in the candidate node set.
4. The method according to claim 1, characterized in that: Execute the process test strategy on any target test node to generate the test result of the hyper-converged architecture, including: Determine a process graph corresponding to any target test node according to the dependency relationship between multiple processes in any target test node, wherein a node in the process graph corresponds to any process, and an edge in the process graph corresponds to a dependency relationship; Determining a closing order of the multiple processes in the target test node according to the process graph; The processes are closed in sequence according to the closing order of the multiple processes, the target test node is restarted, the hyper-converged architecture is tested according to the preset test case, and the test result of the hyper-converged architecture is obtained.
5. The method according to claim 4, characterized in that Determining the closing order of the multiple processes in the target test node according to the process graph includes: Create an in-degree dictionary, an intermediate queue and a result queue respectively, wherein the key of the in-degree dictionary is the process name, the key value is the in-degree of the process, and the in-degree represents the number of dependencies corresponding to any process; According to the process graph, determining the in-degree of any process in the initialized in-degree dictionary; Based on the in-degree dictionary, the intermediate queue and the result queue, a loop sub-strategy is executed to determine the closing order of the multiple processes, and the loop sub-strategy is used to determine the closing order of the multiple processes according to the order of dependency quantity from high to low.
6. The method according to claim 5, characterized in that Executing the loop sub-strategy to determine the closing order of the multiple processes includes: Execute the loop sub-strategy, including: Adding the process whose current in-degree in the in-degree dictionary is 0 to the intermediate queue from the tail of the intermediate queue; Remove the process at the head of the current intermediate queue and add it to the result queue from the tail of the result queue, and reduce the in-degree of any process in the in-degree dictionary that depends on the process by 1; When the intermediate queue is empty, the loop sub-strategy is exited, and the multiple processes in the result queue are sorted from the end to the head as the closing order of the multiple processes.
7. A test result generating device for a hyper-converged architecture, characterized in that: The device comprises: An acquisition module is used to obtain the score of each fusion node in the hyper-converged architecture in each test dimension, and any test dimension represents the target capability of the hyper-converged architecture in the current application scenario; The target test node determination module is used to select a calibrated number of target test nodes according to the scores of each fusion node in each test dimension and the weight of each test dimension. The weight of the test dimension is used to characterize the importance of any test dimension in the current application scenario. A test module is used to execute a process test strategy on any target test node to generate a test result of the hyper-converged architecture. The process test strategy is used to determine the shutdown order of each process in the target test node according to the number of dependencies between processes, and to test the target test node.
8. A computer device, characterized in that: include: At least one processor, and a memory, wherein the memory stores a computer program that can be run on the processor, wherein when the processor executes the computer program, the method for generating test results of the hyper-converged architecture described in any one of claims 1-6 is executed.
9. A non-volatile readable storage medium, characterized in that: The non-volatile readable storage medium stores a computer program, wherein the computer program, when executed by a processor, executes the method for generating test results of a hyper-converged architecture according to any one of claims 1 to 6.
10. A computer program product comprising a computer program / instructions, characterized in that When the computer program / instruction is executed by a processor, the test result generating method of the hyper-converged architecture described in any one of claims 1 to 6 is implemented.