CN112799969A - Testing method, device and system of distributed file system - Google Patents
Testing method, device and system of distributed file system Download PDFInfo
- Publication number
- CN112799969A CN112799969A CN202110375869.4A CN202110375869A CN112799969A CN 112799969 A CN112799969 A CN 112799969A CN 202110375869 A CN202110375869 A CN 202110375869A CN 112799969 A CN112799969 A CN 112799969A
- Authority
- CN
- China
- Prior art keywords
- interface
- test
- target
- server
- file system
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3696—Methods or tools to render software testable
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/10—File systems; File servers
- G06F16/18—File system types
- G06F16/182—Distributed file systems
Abstract
The embodiment of the specification provides a method, a device and a system for testing a distributed file system. The method comprises the following steps: the terminal sends a test request to the server according to the test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters to be transmitted to the target file interface; the server calls a target file interface according to the interface identifier and the parameters through a target working thread to enable the distributed file system to return an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in the plurality of working threads operated by the server; the server sends a test response to the terminal through the target working thread, wherein the test response at least comprises an interface calling result; and the terminal determines the test result of the distributed file system at least according to the test response.
Description
Technical Field
One or more embodiments of the present disclosure relate to the field of computers, and in particular, to a method, an apparatus, and a system for testing a distributed file system.
Background
The distributed file system can dispersedly store large-scale data on a large number of storage nodes, wherein the normal operation of the distributed file system cannot be influenced when part of the storage nodes are failed, and even if files/data on a certain storage node are damaged, the damaged data can be recovered by other storage nodes. Correspondingly, the system structure of the distributed file system is very complex and the cluster scale is large, and the system structure is frequently updated due to frequently changed business requirements.
A new technical scheme is expected to be provided, so that the distributed file system can be tested more conveniently and efficiently, and the quality of the distributed file system is guaranteed.
Disclosure of Invention
One or more embodiments of the present disclosure provide a method, an apparatus, and a system for testing a distributed file system, which can test the distributed file system more conveniently and efficiently.
In a first aspect, a method for testing a distributed file system is provided. The method can comprise the following steps: the terminal sends a test request to the server according to the test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called; then, the server calls the target file interface according to the interface identification and the parameters through a target working thread, so that the distributed file system returns an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by the server; in addition, the server also sends a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result; and finally, the terminal determines the test result of the distributed file system at least according to the test response.
In one possible embodiment, the method further comprises: the terminal sends a connection establishment request to the server; the server processes the connection establishment request through a monitoring thread operated by the server so as to establish communication connection between the terminal and the server; and the server determines a target working thread corresponding to the terminal from the plurality of working threads through the monitoring thread and provides a connection context of the communication connection for the target working thread.
In one possible embodiment, the method further comprises: the terminal acquires the interface identification and the parameters according to the test case; the terminal encapsulates the interface identification and the parameters according to a preset text protocol to obtain the test request; and the server decapsulates the test request according to a predetermined text protocol through a target working thread to obtain the interface identifier and the parameters. Correspondingly, the server calls the target file interface according to the interface identifier and the parameters through a target working thread, and the method specifically includes: and the server transmits the parameters to the target file interface according to the interface identifier through a target working thread.
In one possible implementation, the distributed file system includes a number of metadata nodes and a number of storage nodes. The method further comprises the following steps: and the terminal controls the metadata nodes and the target nodes in the storage nodes to enter an abnormal state according to the disaster tolerance test case, so that the distributed files stored in the target nodes or the metadata of the distributed files cannot be accessed. Correspondingly, the step of sending the test request to the server by the terminal according to the test case specifically comprises the following steps: and the terminal sends a disaster tolerance test request to the server according to the disaster tolerance test case.
In one possible embodiment, the target file interface includes one of the following file interfaces: stat, rename, fdatasync, unlink, pread, pwrite, open, readdir, closedir, mkdir, fsync, and close.
In one possible embodiment, the method further comprises: the server determines a first moment when the server calls the target file interface through the target working thread; and the server determines a second moment when the distributed file system returns the interface calling result through the target working thread. Correspondingly, the terminal determines the test result of the distributed file system at least according to the test response, and specifically includes: and the terminal determines the performance and/or the stability of the distributed file system at least according to the interface calling result and the time difference between the second moment and the first moment. Wherein the test response further comprises the first time and the second time, or the test response further comprises a time difference between the second time and the first time.
In one possible implementation, the target file interface includes pwrite. The parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written once in the target file, and address information to be assigned for storing the test data. Correspondingly, the method further comprises the following steps: and the server selects the test data from random data pre-stored in a preset memory area according to the length information through the target working thread, and assigns values to the address information according to the memory address of the test data. Correspondingly, calling the target file interface according to the interface identifier and the parameters specifically includes: and transmitting the file descriptor, the length information and the assigned address information to the pwrite according to the interface identifier of the pwrite.
In one possible embodiment, the test request further includes a write count for calling the pwrite to write the test data into the target file; the test response specifically includes the interface calling results respectively returned by the distributed file system each time the pwrite is called.
In a second aspect, a testing method for a distributed file system is provided, and is applied to a server. The method comprises the following steps: receiving a test request from a terminal through a target working thread, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, and the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by a server; then, calling the target file interface according to the interface identification and the parameters through the target working thread, and obtaining an interface calling result returned by the distributed file system; and sending a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result, so that the terminal determines the test result of the distributed file system at least according to the test response.
In one possible embodiment, the method further comprises: receiving a connection establishment request from a terminal through a monitoring thread, and processing the connection establishment request to establish a communication connection between the terminal and a server; and determining a target working thread corresponding to the terminal from the plurality of working threads through the monitoring thread, and providing a connection context of the communication connection for the target working thread.
In one possible embodiment, the method further comprises: and de-encapsulating the test request according to a preset text protocol through the target working thread to obtain the interface identifier and the parameters. Correspondingly, the calling the target file interface according to the interface identifier and the parameters through the target working thread specifically includes: and transmitting the parameters to the target file interface according to the interface identifier through the target working thread.
In one possible embodiment, the target file interface includes one of the following file interfaces: stat, rename, fdatasync, unlink, pread, pwrite, open, readdir, closedir, mkdir, fsync, and close.
In one possible embodiment, the method further comprises: determining a first moment when the target working thread calls the target file interface; and determining a second moment when the distributed file system returns the interface calling result through the target working thread. Correspondingly, the test response further includes the first time and the second time, or the test response further includes a time difference between the second time and the first time.
In one possible embodiment, the target file interface includes pwrite; the parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written in the target file once, and address information to be assigned for storing the test data. Correspondingly, the method further comprises the following steps: selecting the test data from random data pre-stored in a preset memory area according to the length information through the target working thread, and assigning values to the address information according to the memory address of the test data. Correspondingly, the calling the target file interface according to the interface identifier and the parameters specifically includes: and transmitting the file descriptor, the length information and the assigned address information to the pwrite according to the interface identifier of the pwrite.
In one possible embodiment, the test request further includes a write count for calling the pwrite to write the test data into the target file; the test response specifically includes the interface calling results respectively returned by the distributed file system each time the pwrite is called.
In a third aspect, a method for testing a distributed file system is provided, which is applied to a terminal. The method comprises the following steps: sending a test request to a server according to a test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, so that the server calls the target file interface and returns a test response containing an interface calling result; and determining a test result of the distributed file system at least according to the test response.
In one possible embodiment, the method further comprises: acquiring the interface identifier and the parameters according to the test case; and encapsulating the interface identifier and the parameters according to a preset text protocol to obtain the test request.
In one possible implementation, the distributed file system includes a number of metadata nodes and a number of storage nodes. The method further comprises the following steps: and controlling the plurality of metadata nodes and a plurality of target nodes in the plurality of storage nodes to enter an abnormal state according to the disaster tolerance test case, so that the distributed files stored in the plurality of target nodes or the metadata of the distributed files cannot be accessed. Correspondingly, sending the test request to the server according to the test case specifically includes: and sending a disaster tolerance test request to a server according to the disaster tolerance test case.
In one possible embodiment, the target file interface includes one of the following file interfaces: stat, rename, fdatasync, unlink, pread, pwrite, open, readdir, closedir, mkdir, fsync, and close.
In a possible implementation manner, the test response further includes a first time when the server calls the target file interface and a second time when the distributed file system returns the interface call result; or, the test response further includes a time difference between a second time when the distributed file system returns the interface calling result and a first time when the server calls the target file interface. Correspondingly, the method further comprises the following steps: and determining the performance and/or the stability of the distributed file system at least according to the interface calling result and the time difference between the second moment and the first moment.
In one possible embodiment, the target file interface includes pwrite; the parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written once in the target file, and address information to be assigned for storing the test data.
In one possible embodiment, the test request further includes a write count for calling the pwrite to write the test data into the target file; the test response specifically includes the interface calling results respectively returned by the distributed file system each time the pwrite is called.
In a fourth aspect, a test system for a distributed file system is provided, which includes: the terminal is configured to send a test request to the server according to the test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called; the server is configured to call the target file interface according to the interface identifier and the parameters through a target working thread, so that the distributed file system returns an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by the server; the server is also configured to send a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result; the terminal is further configured to determine a test result of the distributed file system at least according to the test response.
In a fifth aspect, a testing apparatus for a distributed file system is provided, which is applied to a server. The device includes:
the connection processing unit is configured to be executed by a target working thread operated by the server, so that the target working thread receives a test request from the terminal; the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, and the target working thread is a working thread corresponding to a terminal in a plurality of working threads operated by a server;
the interface calling unit is configured to be executed by the target working thread, so that the target working thread calls the target file interface according to the interface identifier and the parameters, and obtains an interface calling result returned by the distributed file system; and the number of the first and second groups,
the test response unit is configured to be executed by the target working thread, so that the target working thread sends a test response to the terminal; and the test response at least comprises the interface calling result, so that the terminal determines the test result of the distributed file system at least according to the test response.
In a sixth aspect, a testing apparatus for a distributed file system is provided, which is applied to a client. The device includes:
the test request unit is configured to send a test request to a server according to a test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, so that the server calls the target file interface and returns a test response containing an interface calling result;
a result processing unit configured to determine a test result of the distributed file system at least according to the test response.
In a seventh aspect, a computing device is provided, comprising a memory and a processor, the memory having stored therein a computer program, the processor, when executing the computer program, implementing the method according to any one of the second or third aspects.
In an eighth aspect, there is provided a computer readable storage medium having stored thereon a computer program which, when executed in a computing device, the computing device performs the method of any of the second or third aspects.
According to the technical scheme provided in one or more embodiments of the specification, the terminal completes the calling of the target file interface in the distributed file system by utilizing the working thread distributed by the server in cooperation with the terminal, obtains the test result of the distributed file system based on the interface calling result returned by the distributed file system, and can test the distributed file system more conveniently and efficiently.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the drawings used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present disclosure, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without creative efforts.
FIG. 1 is a system framework diagram of the solution provided in the examples of this specification;
fig. 2 is a schematic flowchart of a testing method for a distributed file system provided in an embodiment of the present specification;
FIG. 3 is a flowchart illustrating another testing method for a distributed file system provided in an embodiment of the present disclosure;
fig. 4 is a schematic structural diagram of a testing apparatus of a distributed file system provided in an embodiment of the present specification;
fig. 5 is a schematic structural diagram of a testing apparatus of another distributed file system provided in an embodiment of this specification.
Detailed Description
Various non-limiting embodiments provided by the present specification are described in detail below with reference to the attached figures.
Fig. 1 is one of system framework diagrams of the technical solutions provided in the embodiments of the present specification. As shown in FIG. 1, distributed file system 10 may include several metadata nodes and several storage nodes. The storage nodes are used for storing distributed files, for example, the distributed files are stored in a file storage mode, a block storage mode or an object storage mode, and the metadata nodes are used for storing metadata of the distributed files.
A server (also referred to as a test server) 20 is provided with a client 101 of the distributed file system and a test device 102 for assisting in testing the distributed file system 10, and the server 20 may be connected with a plurality of terminals (also referred to as test terminals) 30 for supporting testing the distributed file system 10. Among other things, the distributed file system 10 is used by the client 101 to provide various file interfaces for external calls in the distributed file system 10. It should be noted that the file interface for external call may include a file interface meeting the POSIX interface standard, specifically, a file interface such as pwrite and pread, and may also include a file interface customized by a service provider or meeting other standards. It should be noted that the server 20 may be a high-performance server including a plurality of computational cores, so that the server 20 may concurrently run a plurality of threads.
The terminal 30 is provided with a testing device 103 for assisting in implementing the testing of the distributed file system 10, and the terminal 30 may obtain a test case written by a worker for the distributed file system 10 through the testing device 103 and trigger the server 20 to implement the calling of the file interface provided by the client 101 through the testing device 102 arranged therein. Accordingly, the terminal 30 can obtain the test result of the distributed file system 10 according to the calling condition of the file interface, thereby completing the test of the distributed file system.
The process of testing the distributed file system 10 is described in detail below in conjunction with the system framework shown in FIG. 1.
Fig. 2 is a flowchart of a testing method of a distributed file system provided in an embodiment of the present specification. As shown in fig. 2, the method may include: step 201, a terminal sends a test request to a server according to a test case, wherein the test request comprises an interface identifier of a target file interface for external calling in a distributed file system and a plurality of parameters required for calling the target file interface; step 203, the server calls the target file interface according to the interface identifier and the parameters through a target working thread, so that the distributed file system returns an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by the server; step 205, the server sends a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result; and step 207, the terminal determines the test result of the distributed file system at least according to the test response.
The terminal completes the calling of the target file interface in the distributed file system by matching with the working thread distributed by the server, and obtains the test result of the distributed file system based on the interface calling result returned by the distributed file system. The framework and the method can support read-write test of large-scale data, are beneficial to performing pressure test and other various types of tests on the distributed file system with a complex structure and a large cluster scale, do not need to deploy a client of the distributed file system in each terminal, and the terminal only needs to be responsible for processing the interaction between the terminal and the server and does not concern the calling process of a file interface, so that a test case for testing the distributed file system is easier to compile; in summary, the technical scheme provided in the embodiments of the present specification can more conveniently and efficiently implement the test of the distributed file system.
Fig. 3 is a flowchart of another testing method for a distributed file system provided in an embodiment of the present specification. The method may include some or all of steps 301 to 313 as shown in fig. 3, where the terminal 30 may implement the respective method steps performed by the terminal 103 by running its deployed testing apparatus 103, and the server 20 may implement the respective method steps performed by the server 20 by the listening thread and the working thread by running its deployed testing apparatus 102.
Step 301, the terminal 30 obtains a test case.
The test case is a test script which is written by a worker according to the test requirements of the distributed file system and has certain test logic, for example, the test script is written by adopting a lightweight scripting language Python. The test case comprises an interface identifier of a target file interface to be called and a plurality of parameters required by calling the target file interface when the distributed file system is tested according to the test case.
The terminal 30 may obtain a plurality of test cases, and the plurality of test cases are used to support a comprehensive function test, a performance test, a stability test, a disaster recovery test, and the like on the distributed file system 10.
In step 302, the terminal 30 sends a connection establishment request to the server 20.
The server 20 can run n working threads including one listening thread and the working threads 1 to n working threads n in the server 20 by running the testing device 102. The value of n may be an integer greater than 1, and the specific value may be determined according to the number of the operation cores in the server 20. Therefore, for the distributed file system with strong service capability, the file interfaces of the distributed file system can be called highly and concurrently through a plurality of working threads operated by the server aiming at the test cases of a complex test scene, so that better pressure test on the distributed file system is facilitated, namely, the performance and the stability of the distributed file system under the high-load condition are facilitated to be tested.
Step 303, the listening thread processes the connection establishment request to establish a communication connection between the terminal and the server.
The listening thread may continuously listen for connection requests for requesting the establishment of a communication connection, which listening for connection establishment requests comprises not only connection establishment requests from the terminal 30 but also connection establishment requests from other terminals for assisting in the implementation of the test of the distributed file system. When the listening thread listens/receives a connection establishment request from the terminal 30, the connection establishment request triggers the listening thread to execute its bound callback function, that is, part of the functions/units in the testing device 102 that trigger the listening thread to bind are executed in the listening thread, so that the listening thread processes the connection establishment request to complete the establishment of the communication connection between the server 20 and the terminal 30. It should be noted that, after the communication connection between the terminal 30 and the server 20 is established, the listening thread and the terminal 30 will obtain the connection context of the communication connection, and the connection context is also expressed as connection information.
In step 304, the listening thread selects a worker thread n from the n worker threads as a target worker thread corresponding to the terminal 30, and sends a connection context of the communication connection to the worker thread n.
A single worker thread may be responsible for processing test requests for multiple terminals. The listening thread may select a target worker thread corresponding to the terminal 30 from the n worker threads according to the number of terminals corresponding to the n worker threads, respectively. In other words, the listening thread may also select another worker thread other than worker thread n as the target worker thread corresponding to the terminal 30.
After receiving the connection context of the communication connection, the target worker thread will continuously listen to the external data write event from the terminal 30 according to the connection context, that is, continuously listen to the test request from its corresponding terminal 30.
When the test case obtained by the terminal 30 is executed, the terminal 30 and the server 20 are triggered to perform part or all of the following steps 305 to 313 to obtain a corresponding test result to complete the test of the distributed file system according to the executed test case.
In step 305, the terminal 30 obtains the interface identifier of the target file interface in the distributed file system and a plurality of parameters required for calling the target file interface according to the test case.
The target file interface may be a file interface that meets the POSIX interface standard, such as one of the following: stat, rename, fdatasync, unlink, pread, pwrite, open, readdir, closedir, mkdir, fsync, and close. But may be other file interfaces that meet other interface standards or are customized by the service provider of the distributed file system 10.
Depending on the test case being executed, the terminal 30 may need to make one or more calls to a single file interface or to make one or more calls to multiple file interfaces, respectively, through the server 20. Accordingly, the terminal 30 may obtain, from the executed test case, the interface identifier of the file interface that is called each time the file interface is called, and several parameters required for calling the file interface. The embodiment describes in detail the process of the terminal 30 calling the file interface once through the server 20 through steps 305 to 312; in other words, the terminal 30 may execute the call to one or more file interfaces multiple times for the executed test case using a process similar to steps 305 to 312.
Illustratively, depending on the test case being executed, the terminal 30 needs to call the file interface pwrite provided by the distributed file system 10 through its client 101 once through the server 20. Then, the executed test case should include the interface identifier of the pwrite, and also include several parameters that need to be transferred to the pwrite when calling the pwrite this time; several of these parameters may include, but are not limited to: the file descriptor of the target file in the distributed file system 10 accessed when the pwrite is called, the length information of the test data written once in the target file, the address information to be assigned (e.g., an unassigned address pointer) to be used for storing the test data, and may further include an address offset at which the test data is written in the target file and/or the number of writes to which the test data is written, and the like.
In step 306, the terminal 30 encapsulates the interface identifier and the parameters according to a predetermined text protocol to obtain a test request to be sent to the server 20. In step 307, the terminal 30 sends a test request to the server 20.
The predetermined text protocol may be a text protocol configured by a worker in a customized manner, or may be an existing text protocol, such as a hypertext transfer protocol. The predetermined text protocol may support the terminal 30 to send a call request (i.e., a test request including an interface identifier and several parameters) for the target file interface to the server, so that the server 20 can accurately call the target file interface provided by the distributed file system 10 to the outside through the client 101 according to the interface identifier and several parameters included in the test request, as desired by the terminal 30.
Step 308, the worker thread n receives the test request from the terminal 30, and decapsulates the test request according to a predetermined text protocol to obtain an interface identifier and a plurality of parameters.
The worker thread n can continuously listen for test requests from the terminal 30 on the basis of the connection information of the communication connection. When the working thread n monitors/receives a test request from the terminal 30, the test request triggers the working thread n to execute its bound callback function, that is, the function/unit in the test device 102 that triggers the binding of the working thread n is executed in the working thread n, so that the working thread n decapsulates the test request according to a predetermined text protocol, obtains an interface identifier and a plurality of parameters, and continues to execute the transaction that needs to be executed by the working thread n in the subsequent process.
When the worker thread n receives the test request from the terminal 30, the worker thread n may first enter a state machine to respond to the network event, and update the current state of the state machine to a conn-read state representing that the worker thread n is processing the test request. The test request is then unpacked according to a predetermined text protocol, for example, the test request is segmented, and the interface identifier and a plurality of parameters to be transmitted to the target file interface are read according to the segmentation result.
When the target file interface is pwrite used to support write operations to a target file of the distributed file system, worker thread n may perform step 309 and then step 310. When the target file interface is not pwrite, worker thread n directly performs step 310.
Step 309, the working thread n selects test data from random data pre-stored in a preset memory area according to the length information, and assigns a value to the address information according to the memory address of the test data.
The initial address when the test data is selected from the preset memory area can be determined through a specific offset algorithm, and the test data is selected from random data pre-stored in the preset memory area according to the initial address. Thus, when a request server calls a pwrite multiple times with a single test request, the test data written to the distributed file system can be made different each time the pwrite is called.
In step 310, the worker thread n calls the target file interface according to the interface identifier and the parameters, and determines a first moment when the worker thread n calls the target file interface. In step 311, the worker thread n obtains the interface call result correspondingly returned by the distributed file system 10, and determines a second time when the distributed file system returns the interface call result.
The worker thread n may pass several parameters to the target file interface according to the interface identifier, for example, send an interface call request containing the interface identifier and several parameters to the client 101, so that several parameters are passed to the target file interface provided by the client 101. The distributed file system 10 then handles the call initiated by the server 20 to the target file interface and returns the corresponding interface call result via the client 101. Correspondingly, the first time of calling the target file interface may be a time when the working thread n sends an interface calling request to the client 101; the second time when the distributed file system 10 returns the interface call result may be the time when the distributed file system 10 returns the interface call result through the client 101.
In a more specific example, when the target file interface is pwrite used to support a write operation on a distributed file in the distributed file system, in step 310, the working thread n may specifically transmit the file descriptor, the length information, and the assigned address information to the pwrite according to an interface identifier of the pwrite, so that the distributed file system writes the test data in the target memory area into the target file. Thus, a relatively small random number is maintained by dividing a memory area in the memory, that is, the random number maintained in the memory area can be repeatedly used by repeatedly calling the file interface, for example, the same or different test data is repeatedly selected from the random number by a specific offset algorithm each time the file interface is called, so that large-scale test data is written into the distributed file system. In addition, test data can be selected from random numbers maintained in the memory area through a similar algorithm, and correctness check can be performed on corresponding data acquired from the distributed file system according to the selected test data.
In a more specific example, when the target file interface is pwrite used to support write operations to a distributed file in a distributed file system, and the test request further includes a number m of writes to write test data to the target file, the server 20 may call pwrite m times in succession. Each time the server 20 calls pwrite, the distributed file system 10 can write p bytes of test data to the target file; then, the terminal 30 sends a test request for requesting to call pwrite to the server 20 once, and the distributed file system 10 writes m × p bytes of large-scale test data into the target file, which can reduce the network overhead of the terminal 30 and the server 20.
The return value actually contained by the interface invocation result may differ depending on the target file interface that is invoked. For example, for partial file interfaces such as open and close, when the server 20 calls any file interface in the partial file interfaces, if the distributed file system 10 successfully processes the call of the server to the file interface, the interface call result may include a return value used for representing that the interface call is successful; if the distributed file system 10 fails to process a server call to the file interface, the result of the interface call may include a return value characterizing the failure of the interface call. As another example, for a file interface such as pre and pwrite that involves direct read/write operations to a target file, the return value included in the interface call result may include the actual length of test data successfully read/written by the distributed file system 10 in the target file, which may not be equal to the expected length of test data expected to be read/written by the server 20 when calling that portion of the interface.
At step 312, worker thread n sends a test response to terminal 30.
The test response includes at least the interface call result. Optionally, the test response further includes the first time and the second time, or the test response further includes a time difference (i.e. a response time) between the second time and the first time.
It should be noted that the working thread n may encapsulate the interface calling result, the first time and the second time according to a predetermined text protocol to obtain a test response; or the worker thread n may encapsulate the interface call result and the time difference between the first time and the second time according to a predetermined text protocol to obtain a test response. The obtained test response is then sent to the terminal 30.
It should be noted that, when the target file interface is pwrite used for supporting write operation on a target file of the distributed file system, and the test request further includes the write number m of the test data written into the target file, the response result may include interface call results respectively corresponding to the server 20 when calling pwrite each time, and a first time and a second time respectively corresponding to the server 20 when calling pwrite each time; alternatively, the response result may include the interface call result corresponding to each time the server 20 calls the pwrite, and the time difference between the second time and the first time corresponding to each time the pwrite is called.
In step 313, the terminal 30 determines a test result of the distributed file system 10 at least according to the test response.
The terminal 30 determines the test result rule of the distributed file system 10 according to the test response, which may be defined by the staff through the executed test case or other implementation manner.
When the test response includes the first time and the second time, or the test response includes a time difference (i.e., a response time) between the second time and the first time, the terminal 30 may specifically determine whether some functions of the distributed file system 10 are normal according to the test response in step 313, and may also determine performance and/or stability of the distributed file system 10 according to the response time.
For example, when the executed test case is used to perform a functional test on the distributed file system, for example, to support testing whether the function of the file interface open, pwrite, or pre is normal, a test result indicating whether the function of the file interface open, pwrite, or pre is normal may be obtained by determining whether a return value included in the interface call result satisfies an expectation.
For example, when the executed test case is used to test the performance of the distributed file system, a test result containing several indexes may be obtained to characterize the performance of the distributed file system. Several metrics may include, but are not limited to, an average of the response time corresponding to each time the server 20 calls the file interface, and may also include a cumulative frequency of calls initiated by the server 20 to the file interface that are successfully processed by the distributed file system 10 per unit time.
Illustratively, when the executed test case is used for testing the stability of the distributed file system 10, the test result that can be used for characterizing the stability of the distributed file system can be obtained based on jitter conditions of the return value and the response time by comparing the return value and the response time respectively corresponding to when the file interface is called for multiple times.
In some embodiments, disaster recovery testing may also be performed on the distributed file system. The test case obtained by the terminal 30 and used for supporting the disaster recovery test on the distributed file system 10 may be expressed as a disaster recovery test case, and when the disaster recovery test case is executed, it may be desirable to ensure that the distributed file system 10 can still normally provide services, such as still being able to receive access and correspondingly provide correct distributed files and metadata of the distributed files, in a case where an abnormality occurs in a part of the storage nodes or metadata nodes, that is, in a case where the distributed files or metadata of the distributed files stored in the part of the storage nodes or metadata nodes cannot be accessed. Accordingly, unlike the embodiment shown in fig. 3, the terminal 30 may further perform, before performing step 305: and controlling a plurality of metadata nodes and a plurality of target nodes in a plurality of storage nodes to enter an abnormal state according to the disaster tolerance test case, so that the distributed files stored in the plurality of target nodes or the metadata of the distributed files cannot be accessed. Correspondingly, the test request sent to the worker thread n in step 307 may specifically be a disaster recovery test request.
For example, the terminal 30 may close several storage nodes in the distributed file 10, so that the target file stored on the closed nodes cannot be accessed. In this case, if the distributed file system 10 can still provide services normally, for example, the terminal 30 initiates to call a lead of the distributed file system 10 through the server 20, and it is expected to read a target file originally stored in a closed storage node; if the distributed file system 10 can successfully return the data expected to be read by the calling pread, it indicates that the distributed file system 10 can restore the distributed file originally stored on the closed storage node, and has a certain disaster tolerance capability.
Based on the same concept as the foregoing method embodiment, the embodiment of the present specification further provides a testing apparatus 102 for a distributed file system, which is applied to the server 20. As shown in fig. 4, the apparatus includes: a connection processing unit 1021, configured to be executed by a target work thread run by a server, so that the target work thread receives a test request from a terminal; the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, and the target working thread is a working thread corresponding to a terminal in a plurality of working threads operated by a server; an interface calling unit 1022, configured to be executed by the target working thread, so that the target working thread calls the target file interface according to the interface identifier and the parameters, and obtains an interface calling result returned by the distributed file system; and, the test response unit 1023, configured to be executed by the target work thread, so that the target work thread sends a test response to the terminal; and the test response at least comprises the interface calling result, so that the terminal determines the test result of the distributed file system at least according to the test response.
Based on the same concept as the foregoing method embodiment, the embodiment of the present specification further provides a testing apparatus 103 of a distributed file system, which is applied to the terminal 30. As shown in fig. 5, the apparatus may include: a test request unit 1031 configured to send a test request to a server according to a test case, where the test request includes an interface identifier of a target file interface for external invocation in the distributed file system and a plurality of parameters required when the target file interface is invoked, so that the server invokes the target file interface and returns a test response including an interface invocation result; a result processing unit 1032 configured to determine a test result of the distributed file system at least from the test response.
Those skilled in the art will recognize that in one or more of the examples described above, the functions described in this specification can be implemented in hardware, software, firmware, or any combination thereof. When implemented in software, a computer program corresponding to these functions may be stored in a computer-readable medium or transmitted as one or more instructions/codes on the computer-readable medium, so that when the computer program corresponding to these functions is executed by a computer, the method executed by the terminal 30 or the server 20 in any embodiment of the present specification is implemented by the computer.
Also provided in embodiments of the present specification is a computer-readable storage medium having a computer program stored thereon, which, when executed in a computing device, performs the method performed by the terminal 30 or the server 20 in any of the embodiments of the present specification.
Also provided in an embodiment of the present specification is a computing device including a memory and a processor, where the memory stores executable codes, and the processor executes the executable codes to implement the method executed by the terminal 30 or the server 20 in any one of the embodiments of the present specification.
The embodiments in the present description are described in a progressive manner, and the same and similar parts in the embodiments are referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, as for the apparatus embodiment, since it is substantially similar to the method embodiment, the description is relatively simple, and for the relevant points, reference may be made to the partial description of the method embodiment.
The foregoing description has been directed to specific embodiments of this disclosure. Other embodiments are within the scope of the following claims. In some cases, some acts or steps may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.
The above-mentioned embodiments, objects, technical solutions and advantages of the present invention are further described in detail, it should be understood that the above-mentioned embodiments are only exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made on the basis of the technical solutions of the present invention should be included in the scope of the present invention.
Claims (20)
1. A testing method of a distributed file system comprises the following steps:
the terminal sends a test request to the server according to the test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called;
the server calls the target file interface according to the interface identification and the parameters through a target working thread to enable the distributed file system to return an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by the server;
the server sends a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result;
and the terminal determines the test result of the distributed file system at least according to the test response.
2. The method of claim 1, further comprising:
the terminal sends a connection establishment request to the server;
the server processes the connection establishment request through a monitoring thread operated by the server so as to establish communication connection between the terminal and the server;
and the server determines a target working thread corresponding to the terminal from the plurality of working threads through the monitoring thread and provides a connection context of the communication connection for the target working thread.
3. The method of claim 1, further comprising:
the terminal acquires the interface identification and the parameters according to the test case;
the terminal encapsulates the interface identification and the parameters according to a preset text protocol to obtain the test request;
the server decapsulates the test request according to a predetermined text protocol through a target working thread to obtain the interface identifier and the parameters;
the server calls the target file interface according to the interface identifier and the parameters through a target working thread, and the method specifically comprises the following steps: and the server transmits the parameters to the target file interface according to the interface identifier through a target working thread.
4. The method of claim 1, wherein the distributed file system includes a number of metadata nodes and a number of storage nodes, the method further comprising: the terminal controls the metadata nodes and the target nodes in the storage nodes to enter an abnormal state according to the disaster tolerance test case, so that the distributed files stored in the target nodes or the metadata of the distributed files cannot be accessed;
the terminal sending the test request to the server according to the test case specifically includes: and the terminal sends a disaster tolerance test request to the server according to the disaster tolerance test case.
5. The method of claim 1, further comprising:
the server determines a first moment when the server calls the target file interface through the target working thread;
the server determines a second moment when the distributed file system returns the interface calling result through the target working thread;
the server sends a test response to the terminal through the target working thread, and the method specifically comprises the following steps: the server includes the first time and the second time in the test response, or the server includes a time difference between the second time and the first time in the test response;
the terminal determines the test result of the distributed file system at least according to the test response, and specifically includes: and the terminal determines the performance and/or the stability of the distributed file system at least according to the interface calling result and the time difference between the second moment and the first moment.
6. The method of any of claims 1-5, wherein the target file interface comprises a pwrite; the parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written in the target file once, and address information to be assigned for storing the test data;
the method further comprises the following steps: the server selects the test data from random data pre-stored in a preset memory area according to the length information through the target working thread, and assigns values to the address information according to the memory address of the test data;
the calling the target file interface according to the interface identifier and the parameters specifically comprises: and transmitting the file descriptor, the length information and the assigned address information to the pwrite according to the interface identifier of the pwrite.
7. A testing method of a distributed file system is applied to a server and comprises the following steps:
receiving a test request from a terminal through a target working thread, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, and the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by a server;
calling the target file interface according to the interface identification and the parameters through the target working thread, and obtaining an interface calling result returned by the distributed file system; and the number of the first and second groups,
and sending a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result, so that the terminal determines the test result of the distributed file system at least according to the test response.
8. The method of claim 7, further comprising:
receiving a connection establishment request from a terminal through a monitoring thread, and processing the connection establishment request to establish a communication connection between the terminal and a server;
and determining a target working thread corresponding to the terminal from the plurality of working threads through the monitoring thread, and providing a connection context of the communication connection for the target working thread.
9. The method of claim 7, further comprising: decapsulating the test request according to a predetermined text protocol through the target working thread to obtain the interface identifier and the parameters;
calling the target file interface according to the interface identifier and the parameters through the target working thread, and specifically comprising: and transmitting the parameters to the target file interface according to the interface identifier through the target working thread.
10. The method of claim 7, further comprising:
determining a first moment when the target working thread calls the target file interface;
determining a second moment when the distributed file system returns the interface calling result through the target working thread;
the test response further includes the first time and the second time, or the test response further includes a time difference between the second time and the first time.
11. The method of any of claims 7 to 10, wherein the target file interface comprises a pwrite; the parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written in the target file once, and address information to be assigned for storing the test data;
the method further comprises the following steps: selecting the test data from random data pre-stored in a preset memory area according to the length information through the target working thread, and assigning values to the address information according to the memory address of the test data;
the calling the target file interface according to the interface identifier and the parameters specifically comprises: and transmitting the file descriptor, the length information and the assigned address information to the pwrite according to the interface identifier of the pwrite.
12. A testing method of a distributed file system is applied to a terminal and comprises the following steps:
sending a test request to a server according to a test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, so that the server calls the target file interface and returns a test response containing an interface calling result;
and determining a test result of the distributed file system at least according to the test response.
13. The method of claim 12, further comprising:
acquiring the interface identifier and the parameters according to the test case;
and encapsulating the interface identifier and the parameters according to a preset text protocol to obtain the test request.
14. The method of claim 12, wherein the distributed file system includes a number of metadata nodes and a number of storage nodes, the method further comprising: controlling a plurality of metadata nodes and a plurality of target nodes in a plurality of storage nodes to enter an abnormal state according to the disaster tolerance test case, so that the metadata of the distributed files or the distributed files stored in the plurality of target nodes cannot be accessed;
sending the test request to the server specifically includes: and sending a disaster tolerance test request to a server according to the disaster tolerance test case.
15. The method of claim 12, wherein the test response further comprises a first time at which the server invokes the target file interface and a second time at which the distributed file system returns the interface invocation result; or the test response further comprises a time difference between a second moment when the distributed file system returns the interface calling result and a first moment when the server calls the target file interface;
the method further comprises the following steps: and determining the performance and/or the stability of the distributed file system at least according to the interface calling result and the time difference between the second moment and the first moment.
16. The method of any one of claims 12 to 15, wherein the target file interface comprises a pwrite; the parameters specifically include a file descriptor of a target file accessed in the distributed file system when the pwrite is called, length information of test data written once in the target file, and address information to be assigned for storing the test data.
17. A test system for a distributed file system, comprising:
the terminal is configured to send a test request to the server according to the test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called;
the server is configured to call the target file interface according to the interface identifier and the parameters through a target working thread, so that the distributed file system returns an interface calling result, wherein the target working thread is a working thread corresponding to the terminal in a plurality of working threads operated by the server;
the server is also configured to send a test response to the terminal through the target working thread, wherein the test response at least comprises the interface calling result;
the terminal is further configured to determine a test result of the distributed file system at least according to the test response.
18. A testing device of a distributed file system is applied to a server and comprises:
the connection processing unit is configured to be executed by a target working thread operated by the server, so that the target working thread receives a test request from the terminal; the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, and the target working thread is a working thread corresponding to a terminal in a plurality of working threads operated by a server;
the interface calling unit is configured to be executed by the target working thread, so that the target working thread calls the target file interface according to the interface identifier and the parameters, and obtains an interface calling result returned by the distributed file system; and the number of the first and second groups,
the test response unit is configured to be executed by the target working thread, so that the target working thread sends a test response to the terminal; and the test response at least comprises the interface calling result, so that the terminal determines the test result of the distributed file system at least according to the test response.
19. A testing device of a distributed file system is applied to a client and comprises:
the test request unit is configured to send a test request to a server according to a test case, wherein the test request comprises an interface identifier of a target file interface for external calling in the distributed file system and a plurality of parameters required when the target file interface is called, so that the server calls the target file interface and returns a test response containing an interface calling result;
a result processing unit configured to determine a test result of the distributed file system at least according to the test response.
20. A computing device comprising a memory having stored therein a computer program and a processor that, when executing the computer program, implements the method of any of claims 7 to 11 or 12 to 16.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110375869.4A CN112799969A (en) | 2021-04-08 | 2021-04-08 | Testing method, device and system of distributed file system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110375869.4A CN112799969A (en) | 2021-04-08 | 2021-04-08 | Testing method, device and system of distributed file system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112799969A true CN112799969A (en) | 2021-05-14 |
Family
ID=75816517
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110375869.4A Pending CN112799969A (en) | 2021-04-08 | 2021-04-08 | Testing method, device and system of distributed file system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112799969A (en) |
Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160202987A1 (en) * | 2012-02-02 | 2016-07-14 | Intel Corporation | Instruction and logic to test transactional execution status |
| CN105808428A (en) * | 2016-03-03 | 2016-07-27 | 南京大学 | Method for performing unified performance test on distributed file system |
| CN106055486A (en) * | 2016-08-19 | 2016-10-26 | 浪潮(北京)电子信息产业有限公司 | Automatic operation maintenance method and platform of distributed file system |
| CN107480039A (en) * | 2017-09-22 | 2017-12-15 | 郑州云海信息技术有限公司 | The small documents readwrite performance method of testing and device of a kind of distributed memory system |
| CN109446071A (en) * | 2018-09-26 | 2019-03-08 | 深圳壹账通智能科技有限公司 | Interface test method, interface test device, electronic equipment and storage medium |
| CN110083524A (en) * | 2019-03-15 | 2019-08-02 | 深圳壹账通智能科技有限公司 | Upload data test method, apparatus, computer equipment and storage medium |
| CN110209556A (en) * | 2018-04-04 | 2019-09-06 | 腾讯科技（深圳）有限公司 | Disaster tolerance test method, method of payment, device, medium and service equipment |
| CN111176974A (en) * | 2019-07-09 | 2020-05-19 | 腾讯科技（深圳）有限公司 | Disaster tolerance testing method and device, computer readable medium and electronic equipment |
| CN111400171A (en) * | 2020-02-27 | 2020-07-10 | 苏州浪潮智能科技有限公司 | Interface testing method, system, device and readable storage medium |
-
2021
- 2021-04-08 CN CN202110375869.4A patent/CN112799969A/en active Pending
Patent Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160202987A1 (en) * | 2012-02-02 | 2016-07-14 | Intel Corporation | Instruction and logic to test transactional execution status |
| CN105808428A (en) * | 2016-03-03 | 2016-07-27 | 南京大学 | Method for performing unified performance test on distributed file system |
| CN106055486A (en) * | 2016-08-19 | 2016-10-26 | 浪潮(北京)电子信息产业有限公司 | Automatic operation maintenance method and platform of distributed file system |
| CN107480039A (en) * | 2017-09-22 | 2017-12-15 | 郑州云海信息技术有限公司 | The small documents readwrite performance method of testing and device of a kind of distributed memory system |
| CN110209556A (en) * | 2018-04-04 | 2019-09-06 | 腾讯科技（深圳）有限公司 | Disaster tolerance test method, method of payment, device, medium and service equipment |
| CN109446071A (en) * | 2018-09-26 | 2019-03-08 | 深圳壹账通智能科技有限公司 | Interface test method, interface test device, electronic equipment and storage medium |
| CN110083524A (en) * | 2019-03-15 | 2019-08-02 | 深圳壹账通智能科技有限公司 | Upload data test method, apparatus, computer equipment and storage medium |
| CN111176974A (en) * | 2019-07-09 | 2020-05-19 | 腾讯科技（深圳）有限公司 | Disaster tolerance testing method and device, computer readable medium and electronic equipment |
| CN111400171A (en) * | 2020-02-27 | 2020-07-10 | 苏州浪潮智能科技有限公司 | Interface testing method, system, device and readable storage medium |
Non-Patent Citations (8)
| Title |
|---|
| ZHIYONG LUO ET AL.: "《file interface parameter testing》", 《 2015 INTERNATIONAL CONFERENCE ON NETWORK AND INFORMATION SYSTEMS FOR COMPUTERS》 * |
| 刘振鹏 等: "《操作系统》", 30 September 2003 * |
| 卢熊远 等: "《标准PASCAL程序设计学习与实践》", 30 June 1987, 中央广播电视大学出版社 * |
| 徐英 等: "《装备试验与评价概论》", 31 October 2016, 北京理工大学出版社 * |
| 戚卓发: "《2001全国计算机技术研讨会论文集》", 31 August 2001, 大连出版社 * |
| 李爱斌: "《Oracle数据库系统原理》", 31 August 2015 * |
| 格里﹒凯恩 等: "《68000汇编语言程序设计》", 31 August 1990, 国防工业出版社 * |
| 牛颖蓓: "《测试过程控制管理系统设计与实现》", 《中国科技纵横》 * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109120678B (en) | Method and apparatus for service hosting of distributed storage system | |
| CN108959385B (en) | Database deployment method, device, computer equipment and storage medium | |
| CN107241315B (en) | Access method and device of bank gateway interface and computer readable storage medium | |
| US10523754B2 (en) | Methods for integrating applications with a data storage network and devices thereof | |
| CN112929401B (en) | Registration method and device | |
| CN113407383B (en) | Main and standby system switching method and device, server and main and standby system | |
| CN113691635B (en) | Method and device for calling microservice, electronic equipment and readable storage medium | |
| CN113076251A (en) | Test method and device | |
| CN110750365A (en) | Remote procedure calling method, system, terminal and storage medium | |
| CN113779452B (en) | Data processing method, device, equipment and storage medium | |
| CN110275701B (en) | Data processing method, device, medium and computing equipment | |
| CN117290557A (en) | Data loading method, related device, equipment and readable storage medium | |
| CN113760522A (en) | Task processing method and device | |
| CN110730197B (en) | Service discovery method and system | |
| CN113472850B (en) | Link data acquisition method, device, system, electronic equipment and storage medium | |
| CN112799969A (en) | Testing method, device and system of distributed file system | |
| CN111064636B (en) | Control method, device and system for connection of front-end processor and computer equipment | |
| CN114691445A (en) | Cluster fault processing method and device, electronic equipment and readable storage medium | |
| CN112131095B (en) | Pressure testing method and device | |
| CN113704355A (en) | Data synchronization method, electronic device and storage medium | |
| CN113760693A (en) | Method and apparatus for local debugging of microservice systems | |
| CN111078311A (en) | Middleware control operation method and system | |
| CN117573396B (en) | Distributed workflow event processing method, device and medium | |
| CN112383434B (en) | Interface simulation method and device for network request, electronic equipment and storage medium | |
| US11941432B2 (en) | Processing system, processing method, higher-level system, lower-level system, higher-level program, and lower-level program |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |