WO2022111635A1

WO2022111635A1 - Method for managing network device, and device and system

Info

Publication number: WO2022111635A1
Application number: PCT/CN2021/133533
Authority: WO
Inventors: 黎楚熙; 戴新宁; 陈锐
Original assignee: 华为技术有限公司
Priority date: 2020-11-30
Filing date: 2021-11-26
Publication date: 2022-06-02
Also published as: CN114640579A

Abstract

Disclosed are a method for managing a network device, and a device and a system, which are used for reducing the waste of network resources. The method comprises: during the process of a server executing a task corresponding to a first RPC request, the server receiving a target request sent by a first client. The target request comprises a first identifier; the first identifier indicates that the server preferentially executes a task corresponding to the target request; the target request comprises a second identifier of the first RPC request; and the target request indicates that the server interrupts, according to the second identifier, the task corresponding to the first RPC request.

Description

Method, device and system for managing network devices

This application claims the priority of the Chinese patent application with the application number 202011378969.4 and the invention titled "Method, Device and System for Managing Network Equipment", which was filed with the China Patent Office on November 30, 2020, the entire contents of which are incorporated herein by reference Applying.

technical field

The embodiments of the present application relate to the field of communications technologies, and in particular, to methods, devices, and systems for managing network devices.

Background technique

The network configuration protocol (NETCONF) is a network protocol that implements the network configuration for managing network devices. The NETCONF network system includes a client and a server, and the client and the server can transmit configuration data, status data and remote procedure calls (RPC) to each other. The client can add, modify or delete the configuration of the network device through NETCONF, and can also obtain the configuration and status information of the network device.

In the related art, when a user needs to execute a new request task preferentially, the user needs to wait for the server to process the currently executing task before starting to execute the new request task, which greatly increases the time for processing urgent tasks or priority tasks, and increases Waste of network resources.

SUMMARY OF THE INVENTION

The present application provides a method, device and system for managing network devices, which can implement priority processing of tasks that need priority processing or urgent, so as to reduce waste of network resources.

In a first aspect, a method for managing a network device is provided. During the server-side executing a task corresponding to a first remote procedure call RPC request, the server-side receives a target request sent by a connected first client, where the target request includes: A first identifier, this first identifier indicates that the server should preferentially execute the task corresponding to the target request, that is, the task priority of the target request is higher, and the target request includes the second identifier of the first RPC request, the server The end can determine the first RPC request or the task corresponding to the first RPC request according to the second identifier, and the target request instructs the server end to interrupt the task corresponding to the first RPC request being executed.

Wherein, that the server side interrupts the task corresponding to the first RPC request being executed can be understood as the server side suspends the execution of the task corresponding to the first RPC request, and preferentially executes the task corresponding to the target request. The task corresponding to the target request may be a cancel-get instruction, which is used to instruct the server to interrupt the specified executing task.

In this embodiment of the present application, after the server side receives the target request sent by the client, the server side can interrupt the task corresponding to the first RPC request being executed by the server side according to the target request, so that the server side can perform priority processing that requires priority processing. Or urgent tasks, reducing the waste of network resources on the server side.

When the client instructs the server to interrupt the task corresponding to the first RPC request, it often sends tasks that need to be prioritized or urgent to the server. The client can instruct the server to execute the second RPC request by sending the second RPC request. The task corresponding to the second RPC request is a task that needs to be prioritized or urgent. It can also be realized by making the target request carry a task that needs to be prioritized or urgent. The following is specifically explained:

In a possible implementation manner, the target request further includes a target task, and the method further includes: the server side interrupts the task corresponding to the first RPC request being executed by the server side according to the target request, and executes the target request according to the target request The corresponding target task, the target task can be a task that needs to be prioritized or urgent. In a possible implementation manner, the target task does not include a task corresponding to instructing the server to interrupt the first RPC request. Optionally, the target task does not include a task corresponding to an instruction to interrupt the first RPC request, and the target task may be an RPC task corresponding to other RPC requests different from the task corresponding to the first RPC request.

In the above implementation manner, the target request further includes a target task, the server can interrupt the task corresponding to the first RPC request and execute the target task, and the server does not need to wait for the task corresponding to the first RPC request to be executed before executing the target task , which speeds up the execution efficiency of the target task; and the target request also includes the target task, and the client can send the target request including the task corresponding to the first RPC request and the target task instructing the server to interrupt the first RPC request to the server, reducing network resources. waste.

In addition, in a possible implementation manner of the first aspect, after the server side receives the target request sent by the first client, the method further includes: the server side receives a second RPC request sent by the second client, the The second RPC request instructs the server to execute the task corresponding to the second RPC request; correspondingly, the server executes the task corresponding to the second RPC request. In a possible implementation manner, the first client and the second client may be the same client, or may be different clients.

In the above method, the server executes the task corresponding to the second RPC request after interrupting the task corresponding to the first RPC request, and the server executes the task corresponding to the second RPC request without waiting for the task corresponding to the first RPC request to be executed. The task corresponding to the second RPC request is preferentially executed, thereby reducing the waste of network resources on the server side.

In a possible implementation manner, the server side interrupts the task corresponding to the first RPC request according to the target request, including: if the server side determines according to the second identifier of the first RPC request that the task being executed by the server side is the If the first RPC requests a task corresponding to the first RPC, the server interrupts the task corresponding to the first RPC being executed.

In the above method, there is specifically provided a solution in which the server side interrupts the task corresponding to the first RPC request according to the target request.

In a possible implementation manner, the server side interrupts the task being executed, including: the server side stops executing the task being executed; or stops executing the task being executed and puts the task identifier corresponding to the first RPC request to the server on the task list on the side.

In a possible implementation manner, the server side arranges tasks that need to be executed but not executed in a task list according to a preset rule, and all tasks in the task list have a one-to-one corresponding identifier. The server side interrupting the task corresponding to the first RPC request according to the target request includes: the server side determines the task corresponding to the first RPC request in the task list according to the second identifier, and the task list includes tasks that have not been executed by the server side. ; The server side deletes the task corresponding to the first RPC request in the task list.

In this possible implementation manner, a solution is specifically provided in which the task corresponding to the first RPC request has not been executed when the server side interrupts the task corresponding to the first RPC request according to the target request, which improves the achievability of the solution. sex.

In a possible implementation manner, the request sent by the client to the server not only includes an RPC request, but also includes a configuration data acquisition request and a status data acquisition request.

In a second aspect, a method for managing a network device is provided. The method includes: a first client sends a target request to the server in the process of executing a task corresponding to the first remote procedure call RPC request, where the target request includes A first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, the target request includes the second identifier, and the target request instructs the server to interrupt the corresponding first RPC request being executed by the server. Task.

In this possible implementation manner, the client can send the target request after sending the first RPC request, so that the server can interrupt the task corresponding to the first RPC request, and the client can interrupt the task executed by the server, thereby reducing the number of servers. waste of network resources.

In a possible implementation manner, the target request further instructs the server to execute the target task corresponding to the target request.

In this possible implementation manner, the target request further includes the target task, and the first client can send the target request including the task corresponding to the first RPC request and the target task instructing the server to interrupt the first RPC request to the server, without sending them separately, reducing the need for Waste of network resources.

In a third aspect, a method for managing network devices is provided, the method specifically includes: a second client sends a second RPC request to the server, where the second RPC request instructs the server to execute a corresponding request for the second RPC Task.

In a possible implementation manner, in this embodiment of the present application, the client that sends the second RPC request and the client that sends the target request are the same client.

In a fourth aspect, a device is provided, the device includes a unit for executing the method for managing a network device provided in the first aspect or any possible implementation manner of the first aspect, for example, the device includes: a receiving unit, Used to receive a target request sent by a first client, the target request includes a first identifier, the first identifier instructs the server to preferentially execute a task corresponding to the target request, and the target request includes a second identifier of the first RPC request , the target request instructs the server to interrupt the task corresponding to the first RPC request being executed by the server.

In a fifth aspect, a device is provided, the device includes a unit for executing the method for managing a network device provided in the second aspect or any possible implementation manner of the second aspect, for example, the device includes: a sending unit, Used to send a target request to the server, the target request includes a first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, the target request includes the second identifier of the first RPC request, the target The request instructs the server to interrupt the task corresponding to the first RPC request being executed by the server.

In a sixth aspect, a client is provided, the client comprising: a sending unit configured to send a second RPC request to a server, where the second RPC request instructs the server to execute a task corresponding to the second RPC request.

The client has the function of implementing the third aspect or the method of any possible implementation manner of the third aspect. This function can be realized by hardware or by software program. The hardware or software includes one or more modules corresponding to the above functions, such as a sending unit.

A seventh aspect provides a server side, the server side includes at least one processor, a memory, a communication interface, and a computer-executable instruction stored in the memory and executable on the processor, when the computer-executable instruction is executed by the processor, The processor executes the method according to the first aspect or any possible implementation manner of the first aspect.

In an eighth aspect, a first client is provided, the first client comprising at least one processor, a memory, a communication interface, and computer-executable instructions stored in the memory and executable on the processor, when the computer-executable instructions are processed When the processor executes, the processor executes the method according to the second aspect or any possible implementation manner of the second aspect.

In a ninth aspect, a second client is provided, the second client comprising at least one processor, a memory, a communication interface, and computer-executable instructions stored in the memory and executable on the processor, when the computer-implemented instructions are processed When the processor executes, the processor executes the method according to the third aspect or any possible implementation manner of the third aspect.

A tenth aspect provides a computer-readable storage medium that stores one or more computer-executable instructions. When the computer-executable instructions or codes are executed by a device, the device is made to perform the above-mentioned first aspect or any one of the first aspects. possible implementation methods.

In an eleventh aspect, a computer-readable storage medium storing one or more computer-executable instructions is provided, when the computer-executable instructions or codes are executed by a device, the device can perform the second aspect or any one of the second aspects described above. method of implementation.

A twelfth aspect provides a computer-readable storage medium that stores one or more computer-executable instructions. When the computer-executable instructions or codes are executed by a device, the device can perform the third aspect or any one of the third aspects. method of implementation.

A thirteenth aspect provides a system including a client and a server. The server side in the system may execute the method of the first aspect or any possible implementation manner of the first aspect. The client in the system may execute the method of the second aspect or any possible implementation manner of the second aspect.

A fourteenth aspect provides a computer program (product), the computer program (product) comprising: computer program code, when the computer program code is executed by a computer, causing the computer to perform the first aspect or the first A method in any possible implementation of the aspect, or performing the second aspect or a method in any possible implementation of the second aspect, performing the third aspect or any possible implementation of the third aspect method in .

Description of drawings

Fig. 1 is the scene schematic diagram of NETCONF network system;

Fig. 2 is a schematic flow chart of the related art;

3 is a schematic flowchart of a method for managing network devices in an embodiment of the present application;

4 is a schematic flowchart of a method for managing network devices in an embodiment of the present application;

5 is a schematic flowchart of a method for managing network devices in an embodiment of the present application;

6 is a schematic structural diagram of a server side in an embodiment of the present application;

FIG. 7 is a schematic structural diagram of a client in an embodiment of the present application;

FIG. 8 is a schematic structural diagram of a client in an embodiment of the present application;

FIG. 9 is a schematic structural diagram of a server side in an embodiment of the present application;

FIG. 10 is a schematic structural diagram of a client in an embodiment of the present application;

FIG. 11 is a schematic structural diagram of a client in an embodiment of the present application;

FIG. 12 is a schematic structural diagram of a NETCONF network system in an embodiment of the present application.

Detailed ways

The terms "first", "second" and the like in the description and claims of the present application and the above drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It is to be understood that data so used may be interchanged under appropriate circumstances so that the embodiments described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having" and any variations thereof, are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those expressly listed Rather, those steps or units may include other steps or units not expressly listed or inherent to these processes, methods, products or devices.

Referring to Figure 1, the network configuration protocol (NETCONF) is a network protocol that manages the network configuration of network devices. The NETCONF network system includes a client and a server. One server can be connected to multiple clients, and the client and the server can transmit configuration data, status data and remote procedure calls (RPC) to each other. The client can add, modify or delete the configuration of the network device on the server side through the NETCONF protocol, and can obtain the configuration and status information of the network device on the server side.

Referring to FIG. 2 , in the related art, when the client performs a new message query, the task being executed by the server cannot be interrupted. For an interactive client, the client may send a new second RPC request, and the server will only process the tasks in the second RPC request after processing the tasks in the first RPC request.

Based on the above-mentioned NETCONF network system, the method for managing network equipment in the embodiment of the present application is described below:

Referring to FIG. 3, in the embodiment of the present application, when the server side executes the task corresponding to the first RPC request, when the client side needs the server side to preferentially execute the second RPC request, the first client side will send a message to the server side with The target request of the first identifier, correspondingly, the server side receives the target request with the first identifier sent by the first client, the target request includes the second identifier of the first RPC request, and the target request instructs the server side to interrupt the server The task corresponding to the first RPC request being executed by the terminal, the first identifier instructs the server to prioritize the processing of the target request, that is, when the server recognizes that the target request carries the first identifier, the server interrupts according to the second identifier The first RPC requests the corresponding task.

In the embodiment of the present application, after the server end interrupts the task corresponding to the first RPC request according to the target request, the server end may execute the target task corresponding to the target request, or may execute the task corresponding to the second RPC sent by the second client. The following are respectively explained:

1. After the server interrupts the task corresponding to the first RPC request according to the target request, the server executes the task corresponding to the second RPC sent by the second client.

Referring to FIG. 4, a process of the method for managing network devices in the embodiment of the present application includes:

401. The first client sends a target request to the server.

During the server-side executing the task corresponding to the first remote procedure call RPC request, the first client-side sends a target request to the server-side, and accordingly, the server-side receives the target-side request sent by the client-side, and the target-side request instructs the server-side to interrupt the server When executing the task corresponding to the first RPC request, the target request includes the second identifier of the first RPC request.

Specifically, the target request has a priority identifier, that is, a first identifier, and the first identifier is used to indicate that the target request is a message that needs to be preferentially processed, and the server side needs to preferentially process the target request after receiving the target request; The target request also includes the second identifier of the first RPC request. For example, the procedure for one embodiment of the target request is as follows:

+---x cancel-get

+----input

|+---w message-id uint32

The target request includes a cancel-get instruction, which is used to instruct the server to interrupt a specified task being executed by the server; the user can enter a preset shortcut instruction on the first client to make the client send the server to the server. Send the instruction; the message-id in the instruction indicates a specified request message, and the message-id includes the second identifier of the first RPC request.

The procedure of another embodiment of the target request is as follows:

<rpc urg="true" message-id="101"

Xmlns="urn:ietf:params:ns:netconf:base:1.0">

<cancel-get Xmlns="urn:huawei:yang:huawei-netconf">

<message-id>100</message-id>

</cancel-get>

</rpc>

The target request includes a cancel-get instruction, which is used to instruct the server side to interrupt a specified task being executed by the server side; the user can input a preset shortcut instruction on the client side to make the first client end to the server side Send the command, for example, the shortcut command can be Ctrl+c. The above urg identifier is a priority identifier, that is, the first identifier, which is used to indicate that the instruction is an emergency instruction with a higher priority than a conventional instruction. After receiving the instruction, the server should prioritize the processing of the message, that is, execute the target request with priority. Corresponding tasks; for example, the server side can set the query instruction and the notification instruction as a regular instruction with a low priority, and set the interrupt instruction as a regular instruction with a high priority. The message-id in the instruction indicates a task corresponding to a specified request message, and the identifier of the message is "101", that is, the second identifier of the first RPC request is 101. After receiving the command, the server will preferentially execute the task corresponding to the interrupt message whose message-id is 101.

402. The server side interrupts the task corresponding to the first RPC request according to the target request.

The server side interrupts the task corresponding to the first RPC request being executed by the server side according to the second identifier of the first RPC request in the target request.

Specifically, when the server side receives the target request, the server side preferentially processes the target request according to the first identifier of the target request. According to the second identifier of the first RPC request in the target request, the server determines whether the second identifier is the same as the identifier of the currently executing task, if the same, interrupts the currently executing task; if not, traverses the The task on the server side determines whether there is an identifier of the task that is the same as the second identifier in the target request, and if so, deletes the task; if not, discards the target request.

403. The second client sends a second RPC request to the server.

The client sends a second RPC request to the server, and accordingly, the server receives the second RPC request sent by the client, and the second RPC request instructs the server to execute the task corresponding to the second RPC request. The task corresponding to the second RPC request is a task that needs to be prioritized or urgent.

404. The server side executes the task corresponding to the second RPC request.

The server performs the task corresponding to the second RPC request according to the second RPC request.

In the embodiment of the present application, the request corresponding to the task being executed by the server and the request sent by the second client to the server are RPC requests, and may actually be messages such as configuration data acquisition requests and status data acquisition requests. There is no limitation here.

In the embodiment of the present application, the server side interrupts the task corresponding to the first RPC request by deleting the identifier of the task corresponding to the first RPC request in the task list of the server side or by stopping the execution of the task being executed. The server side may also not delete the task corresponding to the first RPC request and place the task in the corresponding waiting area on the server side. There are various methods for the server side to implement interrupting the task corresponding to the first RPC request. limited.

In the embodiment of the present application, the server side implements the concurrency of messages for a single session of a single client through the main thread and the worker thread. The concurrency mechanism and the concurrency mechanism based on validity confirmation are used to realize the concurrency of messages for a single session of a single client, which is not specifically limited here.

In this embodiment of the present application, the client that sends the second RPC request to the server is the second client, the client that sends the target request to the server is the first client, and in addition, the second RPC is sent to the server The requesting client and the client sending the target request to the server may also be the same client, which is not limited here.

In this embodiment, the target request instructs the server to interrupt the task corresponding to the first RPC request, and the target request may also instruct the server to execute the task corresponding to the target request, which will be described below:

2. After the server side interrupts the task corresponding to the first RPC request according to the target request, the server side executes the target task corresponding to the target request.

Referring to FIG. 5 , another process of the method for managing network devices in the embodiment of the present application includes:

501. The first client sends a target request to the server.

During the server-side executing the task corresponding to the first remote procedure call RPC request, the first client-side sends a target request to the server-side, and accordingly, the server-side receives the target-side request sent by the client-side, and the target-side request instructs the server-side to interrupt the server When executing the task corresponding to the first RPC request, the target request includes the second identifier of the first RPC request. The target request also instructs the server to execute the target task corresponding to the target request. In this embodiment, the target task does not include the task corresponding to the instruction to interrupt the first RPC request, and the target task may be different from the task corresponding to the first RPC request. The task corresponding to the RPC request.

Specifically, the target request has a priority identifier, that is, a first identifier, and the first identifier is used to indicate that the target request is an urgent message, and the server side needs to prioritize the target request after receiving the target request; the target request Also included is a second identification of the first RPC request. For example, the procedure for one embodiment of the target request is as follows:

+---x cancel-get

+----input

|+---w message-id uint32

The procedure of another embodiment of the target request is as follows:

<rpc urg="true" message-id="101"

Xmlns="urn:ietf:params:ns:netconf:base:1.0">

<cancel-get Xmlns="urn:huawei:yang:huawei-netconf">

<message-id>100</message-id>

</cancel-get>

</rpc>

The target request includes a cancel-get instruction, which is used to instruct the server side to interrupt a specified task being executed by the server side; the user can input a preset shortcut instruction on the client side to make the first client end to the server side Send the command, for example, the shortcut command can be Ctrl+c. The above-mentioned urg identifier can be a priority identifier, that is, the first identifier, which is used to indicate that the instruction is an emergency instruction with a higher priority than a conventional instruction. The corresponding task is requested; for example, the server side can set the query instruction and the notification instruction as a regular instruction with a low priority, and set the interrupt instruction as a regular instruction with a high priority. The message-id in the instruction indicates a task corresponding to a specified request message, and the identifier of the message is "101", that is, the second identifier of the first RPC request is 101. After receiving the command, the server will preferentially execute the task corresponding to the interrupt message whose message-id is 101.

502. The server side interrupts the task corresponding to the first RPC request according to the target request.

In this embodiment of the present application, step 504 is similar to step 402 in FIG. 4 , and details are not repeated here.

503. The server side executes the target task corresponding to the target request.

The server side executes the target task corresponding to the target request according to the target request. In a possible implementation manner, the target task does not include the cancel-get instruction, and the target task is a task corresponding to other RPC requests different from the task corresponding to the first RPC request.

In this embodiment of the present application, the request message corresponding to the task being executed by the server is an RPC request, and may actually be a configuration data acquisition request, a status data acquisition request, or other messages, which are not specifically limited here.

In the embodiment of the present application, the server side interrupts the task corresponding to the first RPC request by deleting the identifier of the task corresponding to the first RPC request in the task list of the server side or interrupting the task being executed. Alternatively, the task corresponding to the first RPC request may not be deleted, and the task may be placed in a corresponding waiting area on the server side. There are various methods for the server side to specifically interrupt the task corresponding to the first RPC request, which is not specifically limited here.

The server side in the embodiment of the present application will be described below. Referring to FIG. 6, a server side 600 provided by the embodiment of the present application may be the server side in the above-mentioned FIG. 4 or FIG. 5, and the server side 600 includes:

A receiving unit 601, configured to receive a target request sent by a first client, where the target request includes a first identifier, the first identifier instructs the server to preferentially execute a task corresponding to the target request, and the target request includes the first RPC request The second identifier of the target request instructs the server to interrupt the task corresponding to the first RPC request being executed by the server. For a specific implementation, please refer to the first client sending a target request to the server in step 401 in FIG. 4 and the first client sending a target request to the server in step 501 in FIG. 5 , which will not be repeated here.

Optionally, the server side 600 may further include a first processing unit 602, and the first processing unit 602 is configured to: if the server side determines according to the second identifier of the first RPC request that the task being executed by the server side is the first When an RPC requests a corresponding task, the server interrupts the task being executed. For the specific implementation, please refer to step 402 in FIG. 4: the server interrupts the task corresponding to the first RPC request according to the target request and step 502 in FIG. 5: the server interrupts the task corresponding to the first RPC request according to the target request, which is not repeated here. Repeat.

Specifically, the first processing unit 602 is configured to execute the target task corresponding to the target request according to the target request. For a specific implementation manner, please refer to step 503 in FIG. 5 : the server side executes the target task corresponding to the target request, which will not be repeated here.

Specifically, the receiving unit is further configured to receive a second RPC request sent by the second client, where the second RPC request instructs the server to execute a task corresponding to the second RPC request. For a specific implementation, please refer to step 403 in FIG. 4 : the second client sends a second RPC request to the server, which will not be repeated here.

Optionally, the server 600 may further include a second processing unit 603, and the second processing unit 603 is configured to execute the task corresponding to the second RPC request. For a specific implementation manner, please refer to step 404 in FIG. 4 : the server side executes the task corresponding to the second RPC request, which will not be repeated here.

Specifically, the first processing unit is further configured to: determine, according to the second identifier of the first RPC request, a task corresponding to the first RPC request in the task list of the server, where the task list includes tasks that have not been executed by the server; or , delete the task corresponding to the first RPC request in the task list. For the specific implementation, please refer to step 402 in FIG. 4: the server interrupts the task corresponding to the first RPC request according to the target request and step 502 in FIG. 5: the server interrupts the task corresponding to the first RPC request according to the target request, which is not repeated here. Repeat.

The division of modules in the embodiments of the present application is schematic, and is only a logical function division. In actual implementation, there may be other division methods. In addition, the functional modules in the various embodiments of the present application may be integrated into one processing unit. In a unit, it can also exist physically alone, or two or more modules can be integrated into one module. The above-mentioned integrated modules can be implemented in the form of hardware, and can also be implemented in the form of software function modules.

In this embodiment, the server side 600 may perform the operations performed by the server side in any of the foregoing embodiments shown in FIG. 4 to FIG. 5 , and details are not repeated here.

The first client in the embodiment of the present application is described below. Referring to FIG. 7 , a client 700 provided by the embodiment of the present application may be the first client in the above-mentioned FIG. 4 or FIG. 5 . The client End 700 includes:

A sending unit 701 is configured to send a target request to the server, where the target request includes a first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, and the target request includes the second RPC request. The target request includes instructing the server to interrupt the task corresponding to the first RPC request. For a specific implementation, please refer to step 401 in FIG. 4 : the first client sends a target request to the server and step 501 in FIG. 5 : the first client sends a target request to the server, which will not be repeated here.

Specifically, the target request further includes instructing the server to execute the target task corresponding to the target request.

In this embodiment, the client 700 may perform the operations performed by the first client in any of the foregoing embodiments shown in FIG. 4 to FIG. 5 , and details are not described herein again.

The client in the embodiment of the present application is described below. Referring to FIG. 8, a client 800 provided by the embodiment of the present application may be the second client in the above-mentioned FIG. 4, and the client 800 includes:

The sending unit 801 is configured to send a second RPC request to the server, where the second RPC request instructs the server to execute the task corresponding to the second RPC request. For a specific implementation, please refer to step 403 in FIG. 4 : the second client sends a second RPC request to the server, which will not be repeated here.

In this embodiment, the client 800 may perform the operations performed by the client in the foregoing embodiment shown in FIG. 4 , and details are not repeated here.

Wherein, when the integrated module can be implemented in the form of hardware, the server side can be the structure shown in FIG. 9 , and the processing unit provided in FIG. 6 can correspond to the processor 901 in FIG. 9 . The processor 901 may be a central processing unit (CPU), a specific integrated circuit (application specific integrated circuit, ASIC), or one or more integrated circuits configured to implement the embodiments of the present application , for example: one or more digital signal processors (digital signal processors, DSP), or, one or more field programmable gate arrays (field programmable gate array, FPGA). The server end may further include a communication interface 902, and the communication interface 902 is used for communicating with other server ends. The server side further includes: a memory 903 for storing programs executed by the processor 901 . The memory 903 can be a volatile memory (volatile memory), such as random-access memory (random-access memory, RAM); or a non-volatile memory (non-volatile memory), such as read-only memory (read-only memory, ROM), flash memory (flash memory), hard disk (hard disk drive, HDD) or solid-state drive (solid-state drive, SSD); or a combination of the above-mentioned types of memories, for storing program codes that can realize the method of the present application , server-side configuration files in the TSN domain, or other content. The memory 903 is, but is not limited to, any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer.

The processor 901 is used for executing the program codes stored in the memory 903 . The specific connection medium between the communication interface 902 , the processor 901 , and the memory 903 is not limited in the embodiments of the present application. In the embodiment of the present application, the memory 903, the processor 902, and the communication interface 902 are connected through a bus 904 in FIG. 9. The bus is represented by a thick line in FIG. 9, and the connection between other components is only for schematic illustration. , is not limited. The bus can be divided into address bus, data bus, control bus and so on.

In an example, the communication interface 902 is configured to receive a target request sent by a first client, where the target request includes a first identifier, where the first identifier indicates that the server side preferentially executes a task corresponding to the target request, and the target request includes the The second identifier of the first RPC request, where the target request includes instructing the server to interrupt the task corresponding to the first RPC request.

The processor 901 is configured to interrupt the task corresponding to the first RPC request according to the target request.

The processor 901 is configured to execute the target task corresponding to the target request according to the target request.

The processor 901 is configured to interrupt the task being executed if the server determines that the task being executed by the server is a task corresponding to the first RPC request according to the second identifier.

Optionally, the processor 901 is configured to determine, according to the second identifier, the task corresponding to the first RPC request in the task list of the server, where the task list is a task that has not been executed by the server, and delete the first task in the task list. A task corresponding to an RPC request.

In an example, the communication interface 902 is configured to receive a first RPC request sent by a client, and receive a target request sent by the client, where the target request includes a first identifier, and the first identifier indicates that the server side preferentially executes the target request The corresponding task, the target request includes the second identifier of the first RPC request, and the target request instructs the server to interrupt the task corresponding to the first RPC request; for receiving the second RPC request sent by the second client, The second RPC request instructs the server to execute the task corresponding to the second RPC request.

The processor 901 is configured to execute the task corresponding to the second RPC request.

Alternatively, the processor 901 is configured to determine, according to the second identifier, the task corresponding to the first RPC request in the task list of the server, where the task list is a task that has not been executed by the server, and delete the first RPC request in the task list corresponding task.

The server side 900 can implement the functions of the server side in FIG. 4 and FIG. 5 , for details, refer to the description of the method related to the drawings.

Wherein, when the integrated module can be implemented in the form of hardware, the first client can be the structure shown in FIG. 10 , and the processing unit provided in FIG. 7 can correspond to the processor 1001 in FIG. 10 . The processor 1001 may be a central processing unit (CPU), a specific integrated circuit (application specific integrated circuit, ASIC), or one or more integrated circuits configured to implement the embodiments of the present application , for example: one or more digital signal processors (digital signal processors, DSP), or, one or more field programmable gate arrays (field programmable gate array, FPGA). The first client may also include a communication interface 1002 for communicating with other clients. The client further includes: a memory 1003 for storing programs executed by the processor 1001 . The memory 1003 may be a volatile memory (volatile memory), such as random-access memory (RAM); or a non-volatile memory (non-volatile memory), such as read-only memory (read-only memory, ROM), flash memory (flash memory), hard disk (hard disk drive, HDD) or solid-state drive (solid-state drive, SSD); or a combination of the above-mentioned types of memories, for storing program codes that can realize the method of the present application , configuration files of clients in the TSN domain, or other content. Memory 1003 is, but is not limited to, any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer.

The processor 1001 is used for executing the program codes stored in the memory 1003 . The specific connection medium between the communication interface 1002 , the processor 1001 , and the memory 1003 is not limited in the embodiments of the present application. In the embodiment of the present application, the memory 1003, the processor 1002, and the communication interface 1002 are connected through a bus 1004 in FIG. 10. The bus is represented by a thick line in FIG. 10, and the connection mode between other components is only for schematic illustration. , is not limited. The bus can be divided into address bus, data bus, control bus and so on.

In an example, the communication interface 1002 is configured to send a target request to the server, where the target request includes a first identifier, the first identifier instructs the server to preferentially execute a task corresponding to the target request, and the target request includes the first RPC The second identifier of the request, the target request instructs the server to interrupt the task corresponding to the first RPC request.

The first server end 1000 can implement the functions of the first server end in FIG. 4 and FIG. 5 , for details, reference may be made to the description of the method related to the drawings.

Wherein, when the integrated module can be implemented in the form of hardware, the second client can be the structure shown in FIG. 11 , and the processing unit provided in FIG. 8 can correspond to the processor 1101 in FIG. 11 . The processor 1101 may be a central processing unit (CPU), a specific integrated circuit (application specific integrated circuit, ASIC), or one or more integrated circuits configured to implement the embodiments of the present application , for example: one or more digital signal processors (digital signal processors, DSP), or, one or more field programmable gate arrays (field programmable gate array, FPGA). The second client may also include a communication interface 1102 for communicating with other clients. The client further includes: a memory 1103 for storing programs executed by the processor 1101 . The memory 1103 may be a volatile memory (volatile memory), such as random-access memory (RAM); or a non-volatile memory (non-volatile memory), such as read-only memory (read-only memory, ROM), flash memory (flash memory), hard disk (hard disk drive, HDD) or solid-state drive (solid-state drive, SSD); or a combination of the above-mentioned types of memories, for storing program codes that can realize the method of the present application , configuration files of clients in the TSN domain, or other content. The memory 1103 is, but is not limited to, any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer.

The processor 1101 is used for executing the program codes stored in the memory 1103 . The specific connection medium between the communication interface 1102 , the processor 1101 , and the memory 1103 is not limited in the embodiments of the present application. In this embodiment of the present application, the memory 1103, the processor 1102, and the communication interface 1102 are connected through a bus 1104 in FIG. 11. The bus is represented by a thick line in FIG. 11, and the connection between other components is only for schematic illustration. , is not limited. The bus can be divided into address bus, data bus, control bus and so on. For ease of presentation, only one thick line is used in FIG. 11, but it does not mean that there is only one bus or one type of bus.

In one example, the communication interface 1102 is configured to send a second RPC request to the server, where the second RPC request instructs the server to perform a task corresponding to the second RPC request.

The second server end 1100 may implement the functions of the second server end in FIG. 4 , for details, reference may be made to the description of the method related to the accompanying drawing.

The NETCONF network system in the embodiment of the present application will be described below. Referring to FIG. 12 , a NETCONF network system 1200 provided by the embodiment of the present application includes the server end 1201 in the embodiment in FIG. 6 , and the embodiment in FIG. 7 . In the first client 1202 and the second client 1203 in the embodiment of FIG. 8 , the server 1201 is connected with the first client 1202 and the second client 1203 respectively.

The system may perform the operations performed by the NETCONF network system in the embodiment shown in any of Figures 4-5.

The server side 1201 is configured to receive a target request sent by the first client, the target request includes a first identifier, the first identifier instructs the server side to preferentially execute the task corresponding to the target request, the target request includes the second identifier, the The target request instructs the server to interrupt the task corresponding to the first RPC request.

The server 1201 is further configured to interrupt the task corresponding to the first RPC request being executed by the server according to the target request, and execute the target task corresponding to the target request according to the target request.

The server end 1201 is further configured to receive a second RPC request sent by the second client, where the second RPC request instructs the server end to perform a task corresponding to the second RPC request.

The server end 1201 is further configured to: the server end determines, according to the second identifier, that the task being executed by the server end is the task corresponding to the first RPC request, and interrupts the task corresponding to the first RPC request being executed.

The server 1201 is further configured to: determine the task corresponding to the first RPC request in the task list of the server according to the second identifier, the task list includes tasks that have not been executed by the server, and delete the first RPC request in the task list corresponding task.

The first client 1202 is configured to send a target request to the server, where the target request includes a first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, the target request includes the second identifier, the target The request instructs the server to interrupt the task corresponding to the first RPC request.

The second client 1203 is configured to send a second RPC request to the server, where the second RPC request instructs the server to execute a task corresponding to the second RPC request.

Embodiments of the present application also provide a computer-readable storage medium, where at least one program instruction or code is stored in the storage medium, and when the program instruction or code is loaded and executed by a processor, the computer realizes the above-mentioned FIG. 4 and FIG. 5 The method for managing network equipment shown in any of the accompanying drawings.

Embodiments of the present application provide a computer program, which, when the computer program is executed by a computer, can cause a processor or computer to execute respective steps and/or processes corresponding to the method embodiments in the foregoing FIG. 4 and FIG. 5 .

An embodiment of the present application provides a chip, including a processor, configured to call and execute an instruction stored in the memory from a memory, so that a communication device installed with the chip executes the method embodiments in the above-mentioned FIG. 4 and FIG. 5 . corresponding steps and/or processes.

An embodiment of the present application provides another chip, including: an input interface, an output interface, a processor, and a memory, the input interface, the output interface, the processor, and the memory are connected through an internal connection path, and the processor is used to execute the The code in the memory, when the code is executed, the processor is configured to execute the corresponding steps and/or processes in the foregoing method embodiments.

As will be appreciated by those skilled in the art, the embodiments of the present application may be provided as a method, a system, or a computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to the present application. It will be understood that each flow and/or block in the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to the processor of a general purpose computer, special purpose computer, embedded processor or other programmable data processing device to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing device produce Means for implementing the functions specified in a flow or flow of a flowchart and/or a block or blocks of a block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory result in an article of manufacture comprising instruction means, the instructions The apparatus implements the functions specified in the flow or flow of the flowcharts and/or the block or blocks of the block diagrams.

These computer program instructions can also be loaded on a computer or other programmable data processing device to cause a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process such that The instructions provide steps for implementing the functions specified in the flow or blocks of the flowcharts and/or the block or blocks of the block diagrams.

Obviously, those skilled in the art can make various changes and modifications to the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalents, the present application is also intended to include these modifications and variations.

Claims

A method for managing network equipment, characterized in that the method comprises:

In the process of the server side executing the task corresponding to the first remote procedure call RPC request, the server side receives a target request sent by the first client, the target request includes a first identifier, and the first identifier indicates the server The terminal preferentially executes the task corresponding to the target request, the target request includes the second identifier of the first RPC request, and the target request instructs the server side to interrupt the correspondence of the first RPC request according to the second identifier task.
The method of claim 1, wherein the target request further comprises a target task;

The method also includes:

The server interrupts the task corresponding to the first RPC request according to the target request;

The server side executes the target task.
The method according to claim 1, wherein after the server side receives the target request sent by the first client, the method further comprises:

receiving, by the server, a second RPC request sent by a second client, where the second RPC request instructs the server to execute a task corresponding to the second RPC request;

The server side executes the task corresponding to the second RPC request.
The method according to claim 2, wherein the server side interrupts the task corresponding to the first RPC request according to the target request, comprising:

The server determines, according to the second identifier, that the task being executed by the server includes the task corresponding to the first RPC request, and interrupts the executing task corresponding to the first RPC.
The method according to claim 2, wherein the server side interrupts the task corresponding to the first RPC request according to the target request, comprising:

The server determines that the task list of the server includes the task corresponding to the first RPC request according to the second identifier;

The server side deletes the task corresponding to the first RPC request in the task list.
A method for managing network equipment, characterized in that the method comprises:

The first client sends a target request to the server, the target request includes a first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, and the target request includes a first remote procedure call The second identifier of the RPC request, the target request instructs the server end to interrupt the task corresponding to the first RPC request being executed by the server end.
The method according to claim 6, wherein the target request further comprises a target task, and the target task is used to instruct the server to execute the target task.
A device, characterized in that the device comprises:

a receiving unit, configured to receive a target request sent by a first client in the process of executing the task corresponding to the first remote procedure call RPC request, where the target request includes a first identifier, and the first identifier indicates that the A task corresponding to a target request, where the target request includes a second identifier of the first RPC request, and the target request includes a task corresponding to the first RPC request that instructs the server end to interrupt the server end being executed.
The device according to claim 8, wherein the target request further comprises a target task;

The device also includes:

A first processing unit, configured to interrupt the task corresponding to the first RPC request according to the target request, and execute the target task according to the target request.
The device according to claim 8, wherein the device further comprises a second processing unit;

The receiving unit is further configured to receive a second RPC request sent by a second client, where the second RPC request instructs the server to execute a task corresponding to the second RPC request;

The second processing unit is configured to execute the task corresponding to the second RPC request.
The device according to claim 9, wherein the first processing unit is specifically configured to: determine, according to the second identifier, that the task being executed by the server is a task corresponding to the first RPC request, and The task corresponding to the first RPC request being executed is interrupted.
The device according to claim 9, wherein the first processing unit is further configured to:

Determine the task corresponding to the first RPC request in the task list on the server side according to the second identifier, where the task list is the task that has not been executed by the device;

Delete the task corresponding to the first RPC request in the task list.
A device, characterized in that the device comprises:

a sending unit, configured to send a target request to the server, where the target request includes a first identifier, the first identifier instructs the server to preferentially execute the task corresponding to the target request, and the target request includes a first remote process The second identifier of the RPC request is called, and the target request instructs the server end to interrupt the task corresponding to the first RPC request that is being executed by the server end.
The device according to claim 13, wherein the target request further comprises a target task instructing the server to execute.
A computer-readable storage medium, characterized in that the computer-readable storage medium comprises instructions or codes, which, when the instructions are executed on a computer, cause the computer to execute the method according to any one of claims 1-7. method.
A computer program product, characterized in that the computer program includes program code, which, when the computer program code is executed by a computer, causes the computer to execute the method according to any one of claims 1-7.
A system, characterized in that the system includes a server and a client, the server executes the method according to any one of claims 1-5, and the client executes the method according to claim 6 or 7 Methods.