CN116455962A - Node management method and system - Google Patents

Abstract

The present application provides a node management method and system, wherein the node management method is applied to a device management node, including: receiving a node allocation request carrying node attribute information, wherein the node attribute information corresponds to a device node; Match the attribute information with the filter conditions corresponding to the sub-service set; determine the target sub-service corresponding to the device node in the sub-service set according to the matching result; based on the node attribute information and the service attribute information of the target sub-service , establishing an association relationship between the device node and the target sub-service, and serving as a response to the node allocation request. According to the node attribute information of the device node itself, it is matched with the appropriate target sub-service, so that the device node can be used to provide the service function corresponding to the target sub-service, which not only ensures the adaptability between the target sub-service and the device node, The processing efficiency of the target sub-service is also guaranteed.

Description

Node management method and system

technical field

The present application relates to the field of computer technology, in particular to a node management method. The present application also relates to a node management system, a package construction system, a package construction method, a computing device, and a computer-readable storage medium.

Background technique

With the development of Internet technology, most enterprises use smart devices to provide computing services. However, there may be huge differences in the computing resources of smart devices held in enterprises. For example, the processor of some smart devices has 4 cores, while the processor of other smart devices has 16 cores. In addition, the disk capacity of some smart devices may be 2T, while the disk capacity of other smart devices is 500G. At present, in order to make reasonable use of the computing resources of these smart devices, the usage of these smart devices is usually specified manually, resulting in an increase in labor costs. Therefore, a technical solution to solve the above problems is urgently needed.

Contents of the invention

In view of this, the embodiment of the present application provides a node management method to solve technical defects in the prior art. Embodiments of the present application also provide a node management system, a package construction system, a package construction method, a computing device, and a computer-readable storage medium.

According to the first aspect of the embodiments of the present application, a node management method is provided, which is applied to a device management node, including:

receiving a node allocation request carrying node attribute information, wherein the node attribute information corresponds to a device node;

Matching the node attribute information with the filter conditions corresponding to the sub-service set;

determining a target sub-service corresponding to the device node in the sub-service set according to the matching result;

Based on the node attribute information and the service attribute information of the target sub-service, establish an association relationship between the device node and the target sub-service, and use it as a response to the node allocation request.

According to a second aspect of the embodiments of the present application, a node management system is provided, including:

Registration node and device management node;

Wherein, the registration node is configured to receive node attribute information submitted by the device node, construct a node assignment request based on the node attribute information, and send the node assignment request to the device management node;

The device management node is configured to receive a node allocation request carrying node attribute information, match the node attribute information with the filter conditions corresponding to the sub-service set; determine the sub-service set according to the matching result The target sub-service corresponding to the device node; based on the node attribute information and the service attribute information of the target sub-service, establish an association relationship between the device node and the target sub-service, and use it as the node allocation request response.

According to a third aspect of the embodiments of the present application, a package construction system is provided, including:

Target task scheduling node, device management node, target task processing node and target task aggregation node,

Wherein, the target task scheduling node is configured to receive the release package construction task, split the release package construction task into construction subtasks, and schedule the task scheduling based on the construction subtask construction task scheduling request. sending the request to the device management node;

The device management node is configured to, in response to the task scheduling request, determine the target task processing node corresponding to the construction subtask, and send the processing node identification information of the target task processing node to the target task scheduling node, wherein the target task processing node is determined in the task processing node set associated with the task processing sub-service in the sub-service set, and the task processing sub-service is determined according to the node attribute information of the target task processing node and the The matching result of the filter condition corresponding to the sub-service set is determined in the sub-service set;

The target task scheduling node is further configured to send the construction subtask corresponding to the release package construction task to the target task processing node based on the processing node identification information;

The target task processing node is configured to pull the sub-release file set corresponding to the construction sub-task, and push the sub-release file set to the target task aggregation node;

The target task aggregation node is configured to construct a target release package corresponding to the release package construction task based on the received sub-release file set.

According to a fourth aspect of the embodiments of the present application, a package construction method is provided, including:

receiving a release package construction task, and splitting the release package construction task into construction subtasks;

Determine the target task processing node corresponding to the construction subtask, and send the construction subtask to the target task processing node, wherein the target task processing node is a task associated with the task processing subservice in the subservice set The task processing sub-service is determined in the sub-service set according to the matching result of the node attribute information of the target task processing node and the filter condition corresponding to the sub-service set;

receiving the sub-release file set returned by the target task processing node based on the construction sub-task;

A target release package corresponding to the release package construction task is constructed based on the set of sub-release files.

According to a fifth aspect of the embodiments of the present application, a computing device is provided, including:

memory and processor;

The memory is used to store computer-executable instructions, and the processor implements the steps of the node management method when executing the computer-executable instructions.

According to a sixth aspect of the embodiments of the present application, there is provided a computer-readable storage medium, which stores computer-executable instructions, and implements the steps of the node management method or the package construction method when the instructions are executed by a processor.

According to a seventh aspect of the embodiments of the present application, there is provided a chip, which stores a computer program, and when the computer program is executed by the chip, implements the steps of the node management method or the package construction method.

The node management method provided by this application, in order to make the device nodes be reasonably utilized, receives node allocation requests carrying node attribute information, wherein the node attribute information corresponds to the device node, and the filter conditions corresponding to the node attribute information and the sub-service set Perform matching, and then determine the target sub-service corresponding to the device node in the sub-service set according to the matching result, so as to match the appropriate target sub-service for it according to the node attribute information of the device node itself; and based on the node attribute information And the service attribute information of the target sub-service, establish the association relationship between the device node and the target sub-service, and use it as a response to the node allocation request, so that the device node can be used to provide the service function corresponding to the target sub-service, which not only ensures the target The adaptability between sub-services and device nodes also ensures the processing efficiency of target sub-services.

Description of drawings

FIG. 1 is a schematic diagram of a node management method provided by an embodiment of the present application;

FIG. 2 is a flow chart of a node management method provided by an embodiment of the present application;

Fig. 3 is a schematic structural diagram of a node management system provided by an embodiment of the present application;

FIG. 4 is a system architecture diagram of a release package construction task in a node management system provided by an embodiment of the present application;

Fig. 5 is a schematic structural diagram of a package construction system provided by an embodiment of the present application;

Fig. 6 is a flow chart of a package construction method provided by an embodiment of the present application;

Fig. 7 is a structural block diagram of a computing device provided by an embodiment of the present application.

Detailed ways

In the following description, numerous specific details are set forth in order to provide a thorough understanding of the application. However, the present application can be implemented in many other ways different from those described here, and those skilled in the art can make similar promotions without violating the connotation of the present application. Therefore, the present application is not limited by the specific implementation disclosed below.

Terms used in one or more embodiments of the present application are for the purpose of describing specific embodiments only, and are not intended to limit the one or more embodiments of the present application. As used in one or more embodiments of this application and the appended claims, the singular forms "a", "the", and "the" are also intended to include the plural forms unless the context clearly dictates otherwise. It should also be understood that the term "and/or" used in one or more embodiments of the present application refers to and includes any and all possible combinations of one or more associated listed items.

It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of the present application, the information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, first may also be referred to as second, and similarly, second may also be referred to as first, without departing from the scope of one or more embodiments of the present application.

In this application, a node management method is provided. The present application also relates to a node management system, a package construction system, a package construction method, a computing device, and a computer-readable storage medium, which are described in detail in the following embodiments one by one.

Referring to Fig. 1, the embodiment of this specification, in order to make the device nodes be reasonably utilized, by receiving the node allocation request carrying the node attribute information, wherein the node attribute information corresponds to the device node, the node attribute information and the corresponding screening of the sub-service set Match the conditions, and then determine the target sub-service corresponding to the device node in the sub-service set according to the matching result, so as to match the appropriate target sub-service for it according to the node attribute information of the device node itself; and based on the node attribute Information and the service attribute information of the target sub-service, establish the association relationship between the device node and the target sub-service, and serve as a response to the node allocation request, so that the device node can be used to provide the service function corresponding to the target sub-service, which not only guarantees The adaptability between the target sub-service and the device node also ensures the processing efficiency of the target sub-service.

FIG. 2 shows a flow chart of a node management method provided according to an embodiment of the present application, which specifically includes the following steps:

Step 202: Receive a node allocation request carrying node attribute information, wherein the node attribute information corresponds to a device node.

Specifically, the node attribute information refers to relevant information used to describe a device node, such as device identification information, operating system information (such as Windows\Mac\Linux, etc.), processor information, memory information, disk information, and the like. Correspondingly, the device node may be a smart device such as a laptop computer, a desktop computer, and a tablet computer. A node allocation request refers to a request for allocating a device node to a sub-service so that it can provide a certain service. For example, assigning a device node to sub-service A means that the device node is used to provide the service function corresponding to sub-service A.

In practical applications, since an enterprise usually contains multiple smart devices, these smart devices may be employees' work computers, servers in the computer room, or other idle smart devices. In order to make better use of these device resources, the smart device can be used as a device node, and a node allocation request is generated based on the node attribute information of the device node and sent to the device management node. Wherein, the device management node refers to an intelligent device that provides device management services to distributed device nodes. In practical applications, there may be one or more device management nodes, which is not limited here.

During specific implementation, the node allocation request may be directly submitted by the device node, or the node allocation request may be sent to the device management node through the registration node, and the node allocation request may also be understood as a node registration request. Wherein, the registration node refers to an intelligent device used to register the device node to the device management node. The registration node receives the node attribute information submitted by the device node, constructs a node assignment request based on the node attribute information, and sends the node assignment request to the device management node, and the node assignment request carries the node attribute information of the device node. Afterwards, the device management node receives the node assignment request carrying the node attribute information.

For example: receiving node attribute information info of device node SERVER1, the node attribute information info includes: device name SERVER1, operating system Windows, processor 16 cores, disk capacity 4T.

Step 204: Match the node attribute information with the filter condition corresponding to the sub-service set.

Specifically, on the basis of receiving the node assignment request above, in order to ensure the rationality of the device node assignment, in the embodiment of this specification, the node attribute information is matched with the filter conditions corresponding to the sub-service set, so as to determine the device node adaptation subservice.

Wherein, the set of sub-services refers to a set of sub-services associated with tasks corresponding to the device management node. Assuming that the task is a computing task, the set of sub-services may include: computing splitting sub-service, computing execution service, computing result sub-service, etc. Assuming that the task is a release package construction task, the sub-service set may include: task scheduling sub-service, task processing sub-service, task aggregation sub-service, task backtracking sub-service, task security sub-service, etc. The filter condition refers to the filter condition corresponding to the sub-service in the sub-service set. For example, the task processing sub-service is a sub-service for task processing, which has high requirements on processors, and the filter condition corresponding to the task processing sub-service may be processor: greater than 8 cores. For example, the task aggregation sub-service is a sub-service for product aggregation, which has high requirements for disk capacity, so the filter condition of the task aggregation sub-service can be disk capacity: greater than 2T.

It should be noted that the sub-service set may include at least two sub-services. Therefore, matching the node attribute information with the filter conditions corresponding to the sub-service set requires matching the node attribute information with the filter conditions of each sub-service in turn. In addition, there may be multiple filter conditions for sub-services. If there are multiple filter conditions, the node attribute information may be matched with each filter condition in turn, and when the node attribute information matches all the filter conditions, determine The matching result of the device node and the sub-service is a match; if any matching result is a mismatch, it is determined that the matching result of the device node and the sub-service is a mismatch.

Further, in order to simplify the matching process and standardize the matching process, the device node can be marked according to the node attribute information. During specific implementation, the label type corresponding to the attribute type of the node attribute information is determined, and the label corresponding to the node attribute information is determined The label information corresponding to the type. Then determine the target label type corresponding to the filter condition based on the sub-service in the sub-service set, and match the label information corresponding to the target label type with the filter condition. Specifically, the matching process can be understood as judging whether the label content satisfies the screening condition. If yes, it indicates that the node attribute information matches the screening node. If not, it indicates that the node attribute information does not match the screening node.

Following the above example, add an operating system label to the device node SERVER1 based on the node attribute information info of the device node SERVER1. The label information of the operating system label is Windows, and add a processor label to the device node SERVER1. The label of the processor label The information is 16 cores, and a disk capacity label is added to the device node SERVER1, and the label information of the disk capacity label is 500G. In the sub-service set, the filter condition of the task processing sub-service is that the processor is greater than 8 cores, and the target label type corresponding to the filter condition is a processor label. 8 cores, therefore, it is determined that the matching result of the node attribute information info and the filter condition of the task processing sub-service is a match.

Step 206: Determine the target sub-service corresponding to the device node in the sub-service set according to the matching result.

Specifically, on the basis of matching the above-mentioned filter conditions corresponding to the node attribute information and the sub-service set, according to the matching result, the sub-service adapted to the device node, that is, the target sub-service can be determined.

During specific implementation, the sub-service corresponding to the filter condition whose matching result is matched is determined as the target sub-service corresponding to the device node, and the filter condition whose matching result is not matched is ignored.

Following the above example, when it is determined that the matching result of the node attribute information info and the filter condition of the task processing sub-service is a match, the task processing sub-service is determined as the target sub-service corresponding to the device node SERVER1.

In practical applications, on the basis of determining the target sub-service corresponding to the device node, considering that the service program corresponding to the target sub-service may not be installed or started in the device node, so the corresponding service function of the target sub-service cannot be provided, Therefore, in the embodiment of this specification, after determining the target sub-service corresponding to the device node in the sub-service set according to the matching result, it further includes:

sending a service startup script corresponding to the target sub-service to the device node;

In case of receiving the startup success information sent by the device node in response to the service startup script, the following step 208 is executed.

Specifically, the service startup script refers to a script used to start a service program corresponding to a target sub-service. In practical applications, if the service program corresponding to the target sub-service has been installed in the device node, the service startup script is the script to start the service program; if the service program corresponding to the target sub-service is not installed in the device node, the service starts When the script runs, it includes installing and starting the application.

Based on this, on the basis of determining the target sub-service corresponding to the device node, in order to enable the device node to provide the target sub-service, a service startup script corresponding to the target sub-service is sent to the device node. The device node receives the service startup script, and by running the service startup script, starts the application corresponding to the target sub-service, and if the application starts successfully, it indicates that the device node has the ability to provide the target sub-service, then execute Step 208 described below.

Following the above example, on the basis of determining the task processing sub-service as the target sub-service corresponding to the device node SERVER1, send the service startup script corresponding to the task processing sub-service to the device node SERVER1, and the device node SERVER1 runs the service startup script, and After the application program corresponding to the target sub-service is started through the service startup script, the startup success information is sent to the device management node. When the device management node receives the startup success information, the following step 208 is executed.

In summary, by sending the service startup script of the target sub-service to the device node, and when the device node is successfully started, the device node is allocated, which ensures that the allocated device node has the service function of the target sub-service, and guarantees stability of service operation.

Step 208: Based on the node attribute information and the service attribute information of the target sub-service, establish an association relationship between the device node and the target sub-service, and use it as a response to the node assignment request.

Specifically, on the basis of determining the target sub-service corresponding to the device node, further establish an association relationship between the device node and the target sub-service, so that the device management node can assign the device node the corresponding target sub-service based on the association relationship. related tasks.

Wherein, the service attribute information refers to information related to the target sub-service. The service attribute information may be the service name, service number, etc. of the target sub-service. Further, establishing the association relationship between the device node and the target sub-service may be adding the device identification information to the lower-level display directory of the service identification information. It may also be to establish a correspondence table between the two, etc., which is not limited here.

Considering that the device node may fail, in order to avoid affecting the normal operation of the target sub-service, it is necessary to know the node status of the device node in time, and to prevent abnormal device nodes from continuing to be assigned tasks related to their corresponding sub-services. In the embodiment of this specification, The node management task can also detect the status of the device node in the following two ways:

Mode 1: Send a state detection instruction to the device node, and receive detection information corresponding to the state detection instruction, and delete the association relationship in response to the abnormal detection information when the detection information is abnormal detection information .

Specifically, the status detection instruction refers to an instruction used to detect the health status of the device node. The status detection instruction may be a ping command, or an instruction to trigger the device node to perform status detection, etc., which is not limited here. Correspondingly, the detection information refers to information returned by executing the status detection instruction. Abnormality detection information, which indicates that the device node is abnormal or faulty. If there is error information or other abnormal information in the detection information, the detection information is determined as abnormal detection information.

Based on this, on the basis of completing the service allocation of the device nodes, in order to ensure the sustainability of the service, a status detection command can be sent to the device nodes according to the preset time period, so as to periodically obtain the status of the device nodes. And when the detection information is abnormal detection information, deleting the association relationship between the device node and the target sub-service means removing the device node from the target sub-service so that it no longer provides the service corresponding to the target sub-service Function.

For example: send a ping command to the device node SERVER1, and receive the timeout information corresponding to the ping command, because the timeout information indicates that the device node SERVER1 has a network failure, that is, the timeout information is abnormal detection information, therefore, delete the device node SERVER1 and the task Handle the relationship between sub-services.

Mode 2: receiving the abnormal reporting information reported by the device node, and deleting the association relationship in response to the abnormal reporting information.

Specifically, the abnormal reporting information refers to the abnormal information sent by the device node to the device management node. In practical applications, after the allocation of the device node is completed, it will maintain a long connection with the node management node in order to process health checks from both parties and abnormal feedback.

For example, after receiving the memory exception information reported by the device node SERVER1, the relationship between the device node SERVER1 and the task processing sub-service is deleted in response to the memory exception information.

In summary, the state monitoring of the device node is carried out in an active and/or passive manner, and when the device node is determined to be abnormal or faulty, the association between the device node and the target sub-service is deleted, which ensures the integrity of the target sub-service. Stability, and reduce the exception handling of sub-service functions.

On the basis of completing the allocation of device nodes, the device nodes can provide corresponding sub-service functions during the task execution process. In the embodiment of this specification, the processing of the release package construction task specifically includes the following steps:

Step 20802: Receive the scheduling node request associated with the release package construction task, and determine the target task scheduling node in the task scheduling node set associated with the task scheduling sub-service in the sub-service set based on the scheduling node request.

Specifically, the task of building a release package refers to a task for building a release package. Wherein, the release package may be an application release package (such as a game program release package, a video program release package, etc.) or a resource release package (such as an education resource release package, a speech resource release package, etc.). Correspondingly, the scheduling node request refers to a request for applying for a task scheduling node.

The task scheduling sub-service refers to the sub-service for splitting the release package construction task and initiating a task scheduling request. Correspondingly, the task scheduling node set refers to a set composed of at least one task scheduling node. Wherein, the task scheduling node refers to a device node for providing task scheduling sub-services. The target task scheduling node refers to the device node used to provide task scheduling sub-services for the release package construction task.

Step 20804: Send the scheduling node identification information of the target task scheduling node to the task requesting node corresponding to the scheduling node request.

The scheduling node identification information refers to information that can uniquely identify the target task scheduling node. For example, the service name and IP address of the target task scheduling node. The task request node refers to the node that initiates the release package construction task.

Based on this, in order to execute the release package construction task, the task request node in the external system can submit the scheduling node request associated with the release package construction task. The target task scheduling node is determined in the task scheduling node set associated with the sub-service. During specific implementation, the target task scheduling node may be randomly selected from the task scheduling nodes. The target task scheduling node may also be selected according to a preset order or a preset rule, which is not limited here. And send the scheduling node identification information of the target task scheduling node to the task requesting node.

Step 20806: Receive the task scheduling request sent by the target task scheduling node based on the release package construction task.

Specifically, the task scheduling request refers to a request for processing the release package construction task.

Based on this, after the task requesting node receives the scheduling node identification information, it sends the publishing package construction task to the target task scheduling node. The target task scheduling node may apply to the task processing node for the publishing package construction task (ie, constructing a task scheduling request and sending the task scheduling request to the device management node).

Step 20808: Based on the task scheduling request, determine the target task processing node in the task processing node set associated with the task processing sub-service in the sub-service set, and send the processing node identification information of the target task processing node to the The target task scheduling node.

Specifically, the task processing sub-service refers to a sub-service for processing the release package construction task. Correspondingly, the task processing node set refers to a set composed of at least one task processing node. Wherein, the task processing node refers to a device node for providing task processing sub-services. The target task processing node refers to the device node used to provide task processing sub-services for the release package construction task. The number of the target task processing nodes may be one or more, which is not limited here.

Further, in order to improve the construction efficiency of the release package construction task, the task scheduling node may split the release package construction task into construction subtasks, and submit a task scheduling request based on the subtask information of the construction subtasks. Therefore, in the embodiment of this specification, based on the task scheduling request, the target task processing node is determined in the task processing node set associated with the task processing sub-service in the sub-service set, and the specific implementation is as follows:

Analyzing the task scheduling request to obtain subtask information corresponding to the release package construction task;

Based on the subtask information, a target task processing node is determined in the task processing node set associated with the task processing subservice in the subservice set.

Specifically, the subtask information refers to information associated with a build subtask corresponding to a release package build task. The subtask information may be the number of subtasks for constructing subtasks, or may be subtask identification information for constructing subtasks. Wherein, the construction subtask refers to a subtask obtained by splitting the release package task. Correspondingly, the subtask identification information refers to information that can uniquely identify the construction of a subtask, such as information such as a subtask name or a subtask code.

Based on this, after receiving the task scheduling request, the device management node can determine the target task processing node in the task processing node set associated with the task processing sub-service in the sub-service set based on the task scheduling request. During specific implementation, the target task scheduling node may be randomly selected from the task scheduling nodes, or the target task scheduling node may be selected from the task processing nodes according to a preset order or preset rules, which is not limited here. In the embodiment of this specification, the task scheduling request is analyzed, the subtask information associated with the construction subtask corresponding to the release package construction task is determined, and the corresponding target is determined in the task processing node set associated with the task processing subservice based on the subtask information The task processing node sends the processing node identification information of the target task processing node to the target task scheduling node.

For example: the device management node analyzes the task scheduling request dQ sent by the target task scheduling node d_Node, and obtains the subtask information corresponding to the release package construction task A: the number of subtasks to be constructed is 2, and the determined number of target task processing nodes 2, and according to the preset screening rules, select 2 target task processing nodes in the task processing node set associated with the task processing sub-service in the sub-service set, where each target task processing node is used to process a construction sub-task . And send the processing node identification information of the two target task processing nodes to the target task scheduling node d_Node.

In summary, based on the subtask information corresponding to the release package construction task, the target task processing node is determined, which realizes the determination of the required target task processing node based on the subtask, ensures the rationality of determining the target task processing node, and improves the release package. Task processing efficiency of build tasks.

Step 20810: Receive the processing result information returned by the target task processing node, and determine the task intermediate result of the release package construction task based on the processing result information.

Specifically, the processing node identification information refers to information that can uniquely identify the target task processing node. The processing result information refers to information used to describe the processing results of the processing and construction subtasks, such as processing completed, processing successful, processing failed, and the like. The task intermediate result refers to the comprehensive processing result of the construction subtasks included in the release package construction task. For example, if the processing result information returned by any target task processing node is processing failure, the intermediate result of the task is processing failure.

Based on this, in the case of multiple target task processing nodes, if the processing result information returned by all target task processing nodes is processing success, it is determined that the task intermediate result of the release package construction task is processing success; there is any target task processing node If the processing result information returned by the task processing node is processing failure, it is determined that the task intermediate result of the release package construction task is processing failure.

To sum up, through the cooperation between the device management node, target task scheduling node and target task processing node, the automatic processing of the release package construction task is realized, which not only ensures the stability of the processing process, but also improves the processing efficiency.

Further, it is considered that if the target task processing node is randomly selected, the selected target task processing node may be too busy, resulting in a situation that the construction of subtasks is not processed in time. Therefore, in the embodiment of this specification, based on the subtask information, the target task processing node is determined in the task processing node set associated with the task processing subservice in the subservice set, and the specific implementation is as follows:

Determine the set of task processing nodes associated with the task processing sub-service, and determine the number of subtasks corresponding to the task processing nodes in the set of task processing nodes;

Sorting the task processing nodes in the task processing node set according to the subtask processing quantity, and screening the target task processing nodes associated with the subtask information in the task processing node set according to the sorting result.

Specifically, the number of subtasks processed refers to the number of currently unfinished subtasks in the task processing node. The more subtasks are processed, the busier the task processing node is. In practical applications, after determining the target task processing node and sending the task processing identification information of the target task processing node to the target task scheduling node, the number of subtasks to be processed can be increased by one, so as to realize the subtask processing of the target task processing node. number of records.

Based on this, in order to realize the rationality of resource allocation, the set of task processing nodes corresponding to the task processing sub-service (that is, the set of task processing nodes) can be determined by means of searching, so as to determine the device nodes that can be used to provide the task processing sub-service . Find the number of subtasks processed by the task processing nodes in the task processing node set, and according to the number of subtasks (such as the order from few to many or the order from many to few), the task processing nodes in the task processing node set Sorting is performed, and according to the sorting result, the task processing node with the least number of subtasks is selected in the task processing node set as the target task processing node associated with the subtask information. Specifically, when the subtask information is the number of subtasks to be constructed, it is necessary to filter the target task processing nodes of the same number as the number of subtasks to be constructed; The target task processing node corresponding to the identification information.

For example: the device management node analyzes the task scheduling request dQ sent by the target task scheduling node d_Node, and obtains the subtask identification information ID1 of the construction subtask sT1 corresponding to the release package construction task A, and the subtask identification information of the construction subtask sT2 On the basis of ID2, based on the service name of the task processing sub-service, the task processing node set corresponding to the task processing sub-service includes 5 task processing nodes, and these 5 task processing nodes are: h_Node1, h_Node2, h_Node3 , h_Node4, h_Node5. Among them, the number of subtasks corresponding to task processing node h_Node1 is 3, the number of subtasks corresponding to task processing node h_Node2 is 5, the number of subtasks corresponding to task processing node h_Node3 is 0, and the number of subtasks corresponding to task processing node h_Node4 is 1. The number of subtasks corresponding to the task processing node h_Node5 is 2. Then, according to the order of the number of subtasks from small to large, the sorting results of these five task processing nodes are: task processing node h_Node3, task processing node h_Node4, task processing node h_Node5, task processing node h_Node1, task processing node h_Node2 . Then according to the sorting results, filter out the top two task processing nodes h_Node3 and task processing node h_Node4, and use the task processing node h_Node3 as the target task processing node corresponding to the subtask identification information ID1, and use the task processing node h_Node4 as the subtask processing node The target task processing node corresponding to the task identification information ID2.

In summary, according to the number of subtasks processed, the target task processing node corresponding to each subtask identification information can be selected in the task processing node set, and the task processing node with a small number of subtask processing can be selected as the target task processing node, which ensures the computing resources Reasonable allocation, so as to make full use of computing power resources, reduce the task processing time extension caused by resource preemption, and greatly speed up the package body construction speed.

In practical applications, there may be a failure of the target task processing node itself, or an abnormality in the process of processing the construction subtask of the target task processing node, resulting in the inability to complete the construction subtask. In order to make the failed construction subtasks be restarted Processing, in the embodiment of this specification, after sending the processing node identification information of the target task processing node to the target task scheduling node, further includes:

Send the processing node identification information to the target task backtracking node associated with the task backtracking sub-service in the sub-service set;

In the case that no processing result information returned by any target task processing node is received within the preset time period, any target task processing node is regarded as a failed target task processing node, and the node management method further includes:

Determine the target processing node identification information of the failed target task processing node;

Construct a subtask query request based on the target processing node identification information, send the subtask query request to the target task backtracking node, and receive the target construction corresponding to the task query request returned by the target task backtracking node Subtasks;

In the task processing node set associated with the task processing sub-service, determine the update task processing node corresponding to the target construction sub-task, and send the construction sub-task to the update task processing node.

Specifically, the task backtracking sub-service refers to a sub-service that provides a task backtracking function. Correspondingly, the target task backtracking node refers to a device node used to provide task backtracking sub-services for the release package construction task. In practical applications, during the task processing of the release package construction task, the processing information of any device node can be sent to the target task backtracking node in the form of logs, so that in the case of any error in the processing process, it can be based on the The processing information stored in the target task backtracking node performs task backtracking, so as to re-execute the wrong part of the task. In addition, when locating abnormal problems during system processing, task backtracking can also be triggered, and specific task backtracking can be performed to locate specific abnormal content.

A failed target task processing node refers to a target task processing node that does not return processing result information. The target processing node identification information refers to the processing node identification information corresponding to the failed target task processing node. The subtask query request refers to a query request for querying failed construction subtasks processed by the target task processing node. The update task processing node refers to the task processing node used to reprocess the failed construction subtask. The target construction subtask refers to the construction subtask that fails to be processed, that is, the construction subtask processed by the failed target task processing node.

Based on this, in order to facilitate the traceback of building subtasks, after sending the processing node identification information of the target task processing node to the target task scheduling node, the processing node information of the target task processing node is sent to the target task traceback node. And if the processing result information returned by the failed target task processing node is not received within the preset time period, a subtask query request is constructed based on the target processing node identification information of the failed target task processing node, and the subtask query request is sent to the target task Backtracking node: the target task backtracking node queries the target construction subtask corresponding to the failed target task processing node based on the target processing node identification information in the subtask query request, and sends the target construction subtask to the device management node, and the device management The node receives the target construction subtask corresponding to the task query request returned by the target task backtracking node. In the task processing node set associated with the task processing sub-service, determine the update task processing node corresponding to the target construction sub-task; and send the target construction sub-task to the update task processing node, so that the target can be constructed by the update task processing node Subtasks perform task processing.

For example: when the target task processing node is h_Node3 and the target task processing node h_Node4, the processing node identification information h_Node3001 of the target task processing node h_Node3 and the processing node identification information h_Node4002 of the target task processing node h_Node4 are sent to the subtask associated with the task backtracking The target task backtracks to node r_Node. The target task backtracking node r_Node receives the identification information of the two processing nodes and stores the identification information of the two processing nodes. If the processing result information returned by the target task processing node h_Node3 is not received within 10 minutes, then the target task processing node h_Node3 is regarded as the failed target task processing node, and the subclass is constructed based on the target processing node identification information h_Node3001 of the failed target task processing node h_Node3 The task query request sq, sends the subtask query request sq to the target task backtracking node r_Node. The target task backtracking node searches based on the target processing node identification information h_Node3001 in the subtask query request sq, determines the target construction subtask corresponding to the target processing node identification information h_Node3001 as sT1, and sends the target construction subtask as sT1 to the device The management node, the device management node determines that the update task processing node corresponding to the target construction subtask sT1 is: task processing node h_Node5, then sends the target construction subtask sT1 to the task processing node h_Node5, so that the task processing node h_Node5 builds the target The subtask file list carried by the subtask is used for file pull.

To sum up, through the backtracking process of the failed target task processing node, the target construction subtask corresponding to the failed target task processing node is determined, and the target construction subtask is sent to the update task processing node for reprocessing, realizing the target construction of the failed processing node Subtasks replace task processing nodes to ensure the robustness of the release package construction task.

In addition, in order to avoid that the failed target task processing node is still used as a task processing node to be scheduled, causing abnormal conditions of other subtasks, the embodiment of this specification also includes:

Delete the target association relationship between the failed target task processing node and the task processing sub-service.

The target association relationship refers to the association relationship between the failed target task processing node and the task processing sub-service.

For example: in the case that the target task processing node h_Node3 is a failed target task processing node, delete the corresponding relationship between the failed target task processing node h_Node3 and the task processing sub-service.

To sum up, if the processing result information returned by the target task processing node is not received within the preset time period, the target association relationship between the target task processing node and the task processing sub-service is deleted to avoid the abnormality of the target task processing node In this case, the target task processing node is still used to process other subtasks, resulting in the failure of other subtasks to be executed smoothly.

In the case where there are multiple target task processing nodes, since each target task processing node only processes a part of tasks, their processing results cannot be used as a complete release package, therefore, the determination of the release based on the processing result information After the task intermediate results of the package build task, also include:

In the case that the intermediate result of the task is processed successfully, the target task aggregation node corresponding to the release package construction task is determined in the task aggregation node set associated with the task aggregation sub-service in the sub-service set, and the target The aggregation node identification information of the task aggregation node is sent to each target task processing node;

The aggregation result information returned by the target task aggregation node is received, and the task construction result of the release package construction task is determined based on the aggregation result information.

Specifically, the task aggregation sub-service refers to a sub-service for aggregating the sub-task products generated by the target task processing node. Correspondingly, the task aggregation node set refers to a set composed of at least one task aggregation node. The target task aggregation node refers to a device node used to provide task aggregation sub-services for the above release package construction tasks. The aggregation node identification information refers to information that can uniquely identify the target task aggregation node. The aggregation node identification information may be the service name or IP address of the target task aggregation node, which is not limited here. The aggregation result information refers to the execution result information of the task aggregation sub-service executed by the target task aggregation node, and the aggregation result information may be aggregation success information, aggregation completion information or aggregation failure information. Correspondingly, the task build result refers to the build result of the release package corresponding to the release package build task, and the build result of the task may be build success or build failure.

It should be noted that the specific implementation of determining the target task aggregation node corresponding to the release package construction task in the task aggregation node set associated with the task aggregation sub-service in the sub-service set is the same as the above-mentioned in the sub-service set The specific implementation of determining the target task processing node in the set of task processing nodes associated with the task processing sub-service is similar, refer to the above-mentioned specific implementation of determining the target task processing node in the set of task processing nodes associated with the task processing sub-service in the sub-service set The method is enough, so I won’t repeat it here.

Based on this, if the task intermediate result is processing success, it indicates that the target task processing node has completed the corresponding construction sub-task, and there is a corresponding task intermediate product (ie, a set of sub-release files). In order to aggregate the sub-published file collections dispersed in multiple target task processing nodes, the device management node needs to determine the target task aggregation node corresponding to the release package construction task in the task aggregation node set associated with the task aggregation sub-service, and Send the aggregation node identification information of the target task aggregation node to each target task processing node. So that each target task processing node sends the set of sub-published files to the target task aggregation node. The target task aggregation node receives the sub-release file sets sent by each target task processing node, and builds the target distribution package corresponding to the release construction task based on these sub-release file sets. And generate aggregated result information according to the construction result, send the aggregated result information to the device management node, the device management node receives the aggregated result information returned by the target task aggregation node, and determine the task construction of the release package construction task based on the aggregated result information result.

For example: in the case that the intermediate result of the task corresponding to the release package construction task A is processed successfully, determine the target task aggregation node t_Node corresponding to the release package construction task A in the task aggregation node set associated with the task aggregation sub-service, and set the target task The aggregation node identification information t_Node0034 of the aggregation node t_Node is sent to the target task processing node h_Node3 and the target task processing node h_Node4, and the target task processing node h_Node3 pulls it from the preset resource management node res_Node according to the subtask file list cTL1 carried by the construction subtask The sub-release file set w_col1 corresponding to the obtained sub-task file list cTL1 is sent to the target task aggregation node t_Node. The target task processing node h_Node4 sends the sub-release file set w_col2 corresponding to the sub-task file list cTL2 pulled from the preset resource management node res_Node according to the sub-task file list cTL2 carried by the construction sub-task to the target task aggregation node t_Node. The target task aggregation node t_Node aggregates the received sub-release file set w_col1 and sub-release file set w_col2 to obtain the target release package. And if the aggregation is successful, the aggregation success information is sent to the device management node, and the device management node determines that the task construction result corresponding to the release package construction task is successful based on the aggregation success information.

In summary, the target task aggregation node selected by the device management node aggregates the processing results of the target task processing node, and determines the task construction result based on the returned aggregation result information, which ensures the accuracy of the release package corresponding to the build release package construction task .

The node management method provided by this application, in order to make the device nodes be reasonably utilized, receives node allocation requests carrying node attribute information, wherein the node attribute information corresponds to the device node, and the filter conditions corresponding to the node attribute information and the sub-service set Perform matching, and then determine the target sub-service corresponding to the device node in the sub-service set according to the matching result, so as to match the appropriate target sub-service for it according to the node attribute information of the device node itself; and based on the node attribute information And the service attribute information of the target sub-service, establish the association relationship between the device node and the target sub-service, and use it as a response to the node allocation request, so that the device node can be used to provide the service function corresponding to the target sub-service, which not only ensures the The adaptability between service and device nodes also ensures the processing efficiency of sub-services.

Corresponding to the above method embodiment, the present application also provides a node management system embodiment, and FIG. 3 shows a schematic structural diagram of a node management system provided by an embodiment of the present application. As shown in Figure 3, the node management system 300 includes:

Registration node 302 and device management node 304;

Wherein, the registration node 302 is configured to receive node attribute information submitted by the device node, construct a node assignment request based on the node attribute information, and send the node assignment request to the device management node 304;

The device management node 304 is configured to receive a node allocation request carrying node attribute information, match the node attribute information with the filter conditions corresponding to the sub-service set; determine the selected sub-service set in the sub-service set according to the matching result The target sub-service corresponding to the device node; based on the node attribute information and the service attribute information of the target sub-service, establish an association relationship between the device node and the target sub-service, and use it as the node allocation request the response to.

Specifically, the registration node 302 refers to an intelligent device used to register a device node to the device management node 304 . The device management node 304 refers to an intelligent device that provides device management services for distributed device nodes. In practical applications, there may be one or more registration nodes 302 and device management nodes 304, which are not limited here.

Device nodes refer to smart devices such as laptops, desktops, or tablets. Correspondingly, node attribute information refers to relevant information used to describe a device node, such as device identification information, operating system information (such as Windows\Mac\Linux, etc.), processor information, memory information, disk information, and the like. A node allocation request refers to a request for allocating a device node to a sub-service so that it can provide a certain service. For example, assigning a device node to sub-service A means that the device node is used to provide the service function corresponding to sub-service A.

The set of sub-services refers to a set of sub-services associated with tasks corresponding to the device management node 304 . Assuming that the task is a computing task, the set of sub-services may include: computing splitting sub-service, computing execution service, computing result sub-service, etc. Assuming that the task is a release package construction task, the sub-service set may include: task scheduling sub-service, task processing sub-service, task aggregation sub-service, task backtracking sub-service, task security sub-service, etc. The filter condition refers to the filter condition corresponding to the sub-service in the sub-service set. For example, the task processing sub-service is a sub-service for task processing, which has high requirements on processors, and the filter condition corresponding to the task processing sub-service may be processor: greater than 8 cores. For example, the task aggregation sub-service is a sub-service for product aggregation, which has high requirements for disk capacity, so the filter condition of the task aggregation sub-service can be disk capacity: greater than 2T.

The service attribute information refers to the information related to the target sub-service. The service attribute information may be the service name, service number, etc. of the target sub-service. Further, establishing the association relationship between the device node and the target sub-service may be adding the device identification information to the lower-level display directory of the service identification information. It may also be to establish a correspondence table between the two, etc., which is not limited here.

In practical applications, since an enterprise usually contains multiple smart devices, these smart devices may be employees' work computers, servers in the computer room, or other idle smart devices. In order to make better use of these device resources, these smart devices can be used as device nodes, and a node allocation request is generated based on the node attribute information of the device nodes and sent to the device management node 304 .

Based on this, the registration node 302 receives the node attribute information submitted by the device node, and constructs a node allocation request based on the node attribute information, which can also be understood as a node registration request. The node allocation request is sent to the device management node 304, and the node allocation request carries node attribute information of the device node. Afterwards, the device management node 304 receives the node allocation request carrying the node attribute information, and matches the node attribute information with the filter conditions corresponding to the sub-service set in order to ensure the rationality of device node allocation. According to the matching result, the sub-service to which the device node is adapted can be determined, that is, the target sub-service. Then establish an association relationship between the device node and the target sub-service, so that the device management node 304 assigns the device node to the relevant task corresponding to the target sub-service based on the association relationship.

For example: receiving node attribute information info of device node SERVER1, the node attribute information info includes: device name SERVER1, operating system Windows, processor 16 cores, disk capacity 4T. Based on the node attribute information info of the device node SERVER1, add an operating system label to the device node SERVER1. The label information of the operating system label is Windows, and add a processor label to the device node SERVER1. The label information of the processor label is 16 cores , and add a disk capacity label to the device node SERVER1, and the label information of the disk capacity label is 500G. The filter condition of the task processing sub-service is that the processor is greater than 8 cores, and the target label type corresponding to the filter condition is a processor label, and the label information of the processor label is matched with the filter condition. Since 16 cores are greater than 8 cores, , determine that the matching result of the node attribute information info and the filter condition of the task processing sub-service is a match. And when it is determined that the matching result of the node attribute information info and the screening condition of the task processing sub-service matches, the task processing sub-service is determined as the target sub-service corresponding to the device node SERVER1.

In practical applications, on the basis of completing the allocation of device nodes, the device nodes can provide corresponding sub-service functions during the task execution process. Due to the existence of multiple sub-services, the device nodes managed by these sub-services are important in the execution of the release package construction task. During the process, they can cooperate with each other to complete the relevant task processing of the release package construction task. In the embodiment of this specification, the node management system 300 further includes: a target task scheduling node;

The device management node 304 is further configured to receive a request from a dispatching node associated with a publishing package construction task, determine a target task dispatching node associated with a task dispatching sub-service in the sub-service set based on the dispatching node request; and The scheduling node identification information of the target task scheduling node is sent to the scheduling node to request the corresponding task request node;

The target task scheduling node is configured to receive the release package construction task submitted by the task request node, construct a task based on the release package, construct a task scheduling request, and send the task scheduling request to the device management node 304;

The device management node 304 is further configured to determine a target task processing node in the task processing node set associated with the task processing sub-service in the sub-service set based on the task scheduling request, and assign the target task processing node to Send the identification information of the processing node to the target task scheduling node.

Based on this, in order to execute the release package construction task, the task request node in the external system may submit a dispatch node request associated with the release package construction task. The target task scheduling node is determined in the task scheduling node set associated with the scheduling sub-service. During specific implementation, the target task scheduling node may be randomly selected from the task scheduling nodes. The target task scheduling node may also be selected according to a preset order or a preset rule, which is not limited here. And send the scheduling node identification information of the target task scheduling node to the task requesting node.

After the task request node receives the scheduling node identification information, it sends the release package construction task to the target task scheduling node. The target task scheduling node constructs the task application target task processing node based on the release package (that is, constructs a task scheduling request and sends the task scheduling request to the device management node 304). During specific implementation, the target task scheduling node constructs tasks based on the release package, and there are various ways to construct task scheduling requests. For example, the target task scheduling node can determine the required storage capacity according to the release package corresponding to the release package construction task. The number of nodes to apply for the target task processing node; specifically, the larger the storage capacity, the more the number of nodes to apply for, and a task scheduling request is constructed based on the number of nodes.

After receiving the task scheduling request, the device management node 304 can determine the target task processing node in the task processing node set associated with the task processing sub-service in the sub-service set based on the task scheduling request. During specific implementation, the target task scheduling node may be randomly selected from the task scheduling nodes, or the target task scheduling node may be selected from the task processing nodes according to a preset order or preset rules, which is not limited here. And send the processing node identification information of the target task processing node to the target task scheduling node.

For example: the device management node 304 receives the release package submitted by the task request node q_Node to construct the scheduling node request nQ associated with task A, and based on the scheduling node request nQ, determines the target in the task scheduling node set associated with the task scheduling sub-service in the sub-service set The task scheduling node d_Node sends the scheduling node identification information of the target task scheduling node d_Node: d_Node0234 to the scheduling node request nQ, and the scheduling node requests nQ to receive the scheduling node identification information: d_Node0234, and sends the release package construction task A to the Scheduling node identification information: the target task scheduling node d_Node corresponding to d_Node0234. After the target task scheduling node d_Node receives the release package construction task A, based on the release package type carried in the release package task: incremental package, it is determined that the number of target task processing nodes that need to be applied for is 2, and then build based on the number of nodes 2 The task scheduling request dQ sends the task scheduling request dQ to the device management node 304. Based on the number of nodes carried in the task scheduling request dQ 2, the device management node 304 associates the task processing sub-services in the sub-service set according to the preset screening rules Select two target task processing nodes from the set of task processing nodes, and send the processing node identification information of the two target task processing nodes to the target task scheduling node d_Node.

To sum up, the device management node 304 determines the target task scheduling node corresponding to the release package construction task, and the target task scheduling node builds a task based on the release package and constructs a task scheduling request, so that the device management node 304 determines the task to be scheduled based on the task scheduling request. The target task processing node sends the processing node identification information of the target task processing node to the target task scheduling node, realizing the scheduling of the target task processing node required for the release package construction task.

Specifically, in order to ensure the rationality of sending the processing node identification information of the target task processing node to the target task processing node applied by the target task scheduling node, so as to improve the efficiency of task processing, in the embodiment of this specification, the node management The system also includes: a target task processing node;

The target task scheduling node is further configured to split the release package construction task into construction subtasks, and construct a task scheduling request based on subtask information associated with the construction subtasks corresponding to the release package construction task;

Correspondingly, the device management node 304 is further configured to parse the task scheduling request to obtain subtask information corresponding to the release package construction task; based on the subtask information, in the subservice set Determine the target task processing node in the task processing node set associated with the task processing sub-service; and send the processing node identification information of the target task processing node to the target task scheduling node;

The target task scheduling node is further configured to send the construction subtask corresponding to the release package construction task to the target task processing node based on the processing node identification information;

The target task processing node is configured to pull the sub-release file set corresponding to the sub-task file list from the preset resource management node according to the sub-task file list carried by the construction sub-task, and when the pulling is completed, In this case, send processing result information to the device management node 304;

The device management node 304 is further configured to receive the processing result information returned by the target task processing node, and determine the task intermediate result of the release package construction task based on the processing result information.

Specifically, the subtask file list refers to a task file list corresponding to building a subtask, and the subtask file list includes information such as names and/or locations of files to be pulled to build a subtask. The default resource management node refers to a device node used to manage and store resources to be released. The sub-release file set refers to a set composed of resource files corresponding to build subtasks.

Based on this, in order to improve the construction efficiency of the release package construction task, the target task scheduling node splits the release package construction task into construction subtasks, and then constructs a task scheduling request based on the subtask information associated with the construction subtasks corresponding to the release package construction task. Specifically, the subtask information refers to information associated with a build subtask corresponding to a release package build task. The subtask information may be the number of subtasks for constructing subtasks, or may be subtask identification information for constructing subtasks.

The device management node 304 analyzes the task scheduling request, determines the subtask information associated with the construction subtask corresponding to the release package construction task, and determines the corresponding target task processing node set in the task processing node set associated with the task processing subservice based on the subtask information The node sends the processing node identification information of the target task processing node to the target task scheduling node.

After receiving the processing node identification information, the target task scheduling node sends the construction subtask corresponding to the release package construction task to the target task processing node corresponding to the processing node identification information based on the processing node identification information. After the target task processing node receives the construction subtask, it is due to the list of subtask files carried by the construction subtask. Therefore, the target task processing node can pull the sub-release file set corresponding to the sub-task file list from the preset resource management node according to the sub-task file list carried by the construction sub-task. And when the pulling is completed, the processing result information is sent to the device management node 304 .

For example: after the target task scheduling node d_Node receives the release package construction task A, it splits the release package construction task A into two construction subtasks, and constructs a task scheduling request dQ according to the number of construction subtasks of the construction subtasks. The device management node 304 analyzes the task scheduling request dQ sent by the target task scheduling node d_Node, and obtains 2 construction subtasks corresponding to the release package construction task A, then the determined number of target task processing nodes is 2, and according to The preset filtering rules filter two target task processing nodes: h_Node3 and h_Node4 in the task processing node set associated with the task processing sub-service in the sub-service set, and send the processing node identification information of these two target task processing nodes to the target Task scheduling node d_Node. The target task scheduling node d_Node sends the two construction subtasks to the two target task processing nodes respectively. The target task processing node h_Node3 lists the subtask files carried by it according to the construction subtask

cTL1, the sub-release file collection corresponding to the sub-task file list cTL1 pulled from the preset resource management node res_Node

w_col1, the target task processing node h_Node4 uses the subtask file list cTL2 carried by the construction subtask to pull the subtask file list cTL2 corresponding to the subtask file set w_col2 from the preset resource management node res_Node, and completes the pull In this case, the processing result information is sent to the device management node 304 . The device management node 304 receives the processing result information returned by the target task processing nodes h_Node3 and h_Node4, both of which are pulled successfully, and then determines that the task intermediate result of the release package construction task A is processed successfully.

In summary, based on the subtask information of the construction subtask corresponding to the release package construction task, the target task processing node is determined, which realizes the determination of the required target task processing node based on the construction subtask, and ensures the rationality of determining the target task processing node. And the task processing efficiency of the release package construction task is improved.

Optionally, to ensure the rationality of splitting the release package construction task, in the embodiment of this specification, it is necessary to first determine the task file list corresponding to the release package construction task, and then split based on the task file list. The target task scheduling The node is further configured to: obtain release package information carried by the release package construction task; determine a task file list based on the release package information; split the task file list into subtask files according to a preset split strategy list, and build corresponding build subtasks based on each subtask file list.

Further, the target task scheduling node splits the release package construction task into construction subtasks, and the specific implementation is as follows:

Obtain the release package information carried by the release package construction task; determine the task file list based on the release package information; split the task file list into subtask file lists according to the preset split strategy, and based on each subtask File list build corresponding build subtasks.

Specifically, the release package information can be understood as the relevant information of the release package to be built, such as the release package type (incremental package type, repair package type, full package type and/or streaming package type, etc.), or the release package file location and other information. Based on the release package information, a task file list corresponding to the release package construction task can be determined, wherein, the task file list refers to a list of resource files required for the release package construction task. The list may include information about resource files, such as file names, file directories, and other information. And the task file list is split to obtain the subtask file list.

Based on this, according to the release package information, determine the task file list corresponding to the release package task, and then split the task file list into subtask file lists. Specifically, split the task file list, which can be split according to the file directory , can also be divided by the number of resource files, in addition, can also be divided according to the file size, etc., there is no limit here. Further, corresponding subtask identification information may be added to the split subtask file list to generate a construction subtask.

For example: when the release package information is the release package type: incremental package, version comparison is required to determine the task file list TL corresponding to the incremental package, and then according to the number of files in the task file list TL 1000, and the preset Number of splits: 500, split the release package build task into two build subtasks: build subtask sT1 and build subtask sT2, each build subtask corresponds to a subtask file list containing 500 resource files.

In summary, determining the task file list based on the release package information ensures the accuracy of the task file list. Based on the splitting of the task file list, the splitting of the release package construction task is realized, which increases the flexibility and rationality of the splitting.

In the case where there are multiple target task processing nodes, since each target task processing node only processes a part of tasks, their processing results cannot be used as a complete release package. In the embodiment of this specification, the node management system 300 also includes : target task aggregation node;

The device management node 304 is further configured to determine the target corresponding to the release package construction task in the task aggregation node set associated with the task aggregation sub-service in the sub-service set when the intermediate result of the task is processing success a task aggregation node, and send the aggregation node identification information of the target task aggregation node to each target task processing node;

The target task processing node is further configured to push the set of sub-published files to the target task aggregation node corresponding to the aggregation node identification information;

The target task aggregation node is configured to construct the target release package corresponding to the release package construction task based on the received sub-release file set, generate aggregated result information according to the construction result, and send the aggregated result information to the device management node 304;

The device management node 304 is further configured to receive the aggregation result information returned by the target task aggregation node, and determine the task construction result of the release package construction task based on the aggregation result information.

Specifically, the task aggregation sub-service refers to a sub-service for aggregating the sub-task products (ie, the set of sub-published files) generated by the target task processing node. Correspondingly, the task aggregation node set refers to a set composed of at least one task aggregation node. The target task aggregation node refers to a device node used to provide task aggregation sub-services for the above release package construction tasks. The aggregation node identification information refers to information that can uniquely identify the target task aggregation node. The aggregation node identification information may be the service name or IP address of the target task aggregation node, which is not limited here. The aggregation result information refers to the execution result information of the task aggregation sub-service executed by the target task aggregation node, and the aggregation result information may be aggregation success information, aggregation completion information or aggregation failure information. Correspondingly, the task construction result refers to the construction result of the release package corresponding to the release package construction task (that is, the target release package). The task construction result may be a successful build or a build failure.

Based on this, if the intermediate result of the task is processing successfully, it indicates that the target task processing node has completed the corresponding construction sub-task, and there is a corresponding set of sub-release files. In order to aggregate the sub-published file sets dispersed in multiple target task processing nodes, it is necessary for the device management node 304 to determine the target task aggregation node corresponding to the release package construction task in the task aggregation node set associated with the task aggregation sub-service, And send the aggregation node identification information of the target task aggregation node to each target task processing node. So that each target task processing node sends the set of sub-published files to the target task aggregation node. The target task aggregation node receives the sub-release file sets sent by each target task processing node, and builds the target distribution package corresponding to the release build task based on these sub-release file sets, the released version information, and the release program. And generate aggregation result information according to the construction result, send the aggregation result information to the device management node 304, the device management node 304 receives the aggregation result information returned by the target task aggregation node, and determines the release package construction task based on the aggregation result information Task build result.

For example: in the case that the intermediate result of the task corresponding to the release package construction task A is processed successfully, determine the target task aggregation node t_Node corresponding to the release package construction task A in the task aggregation node set associated with the task aggregation sub-service, and set the target task The aggregation node identification information t_Node0034 of the aggregation node t_Node is sent to the target task processing node h_Node3 and the target task processing node h_Node4, and the target task processing node h_Node3 pulls it from the preset resource management node res_Node according to the subtask file list cTL1 carried by the construction subtask The sub-release file set w_col1 corresponding to the obtained sub-task file list cTL1 is sent to the target task aggregation node t_Node. The target task processing node h_Node4 sends the sub-release file set w_col2 corresponding to the sub-task file list cTL2 pulled from the preset resource management node res_Node according to the sub-task file list cTL2 carried by the construction sub-task to the target task aggregation node t_Node. The target task aggregation node t_Node aggregates the received sub-release file set w_col1 and sub-release file set w_col2 to obtain the target release package. If the aggregation is successful, the aggregation success information is sent to the device management node 304, and based on the aggregation success information, the device management node determines that the task construction result corresponding to the release package construction task is a successful construction.

In summary, the target task aggregation node selected by the device management node 304 aggregates the processing results of the target task processing node, and determines the task construction result based on the returned aggregation result information, which ensures the accuracy of the release package construction task.

In practical applications, there may be a failure of the target task processing node itself, or an abnormality in the process of processing the construction subtask of the target task processing node, resulting in the inability to complete the construction subtask. In order to make the failed construction subtasks be restarted Processing, in the embodiment of this specification, the node management system 300 further includes: a target task backtracking node;

The device management node 304 is further configured to send the processing node identification information to the target task backtracking node associated with the task backtracking sub-service in the sub-service set;

The target task scheduling node is further configured to send each construction subtask and the processing node identification information corresponding to each construction subtask to the target task backtracking node;

If no processing result information returned by any target task processing node is received within the preset time period, any target task processing node is regarded as a failed target task processing node, and the device management node 304 is further configured to determine the Target processing node identification information of the failed target task processing node; constructing a subtask query request based on the target processing node identification information, and sending the subtask query request to the target task backtracking node;

The target task backtracking node is configured to query the target construction subtask corresponding to the failed target task processing node based on the target processing node identification information carried in the subtask query request, and send the target construction subtask to the device management node 304;

The device management node 304 is further configured to receive the target construction subtask corresponding to the subtask query request returned by the target task backtracking node; in the set of task processing nodes associated with the task processing sub-service, determine the an update task processing node corresponding to the target construction subtask, and send the target construction subtask to the update task processing node.

Specifically, the task backtracking sub-service refers to a sub-service that provides a task backtracking function. Correspondingly, the target task backtracking node refers to a device node used to provide task backtracking sub-services for the release package construction task. In practical applications, during the task processing of the release package construction task, the processing information of any device node can be sent to the target task backtracking node in the form of logs, so that in the case of any error in the processing process, it can be based on the The processing information stored in the target task backtracking node performs task backtracking, so as to re-execute the wrong part of the task. In addition, when locating abnormal problems during system processing, task backtracking can also be triggered, and specific task backtracking can be performed to locate specific abnormal content.

A failed target task processing node refers to a target task processing node that does not return processing result information. The target processing node identification information refers to the processing node identification information corresponding to the failed target task processing node. The subtask query request refers to a query request for querying failed construction subtasks processed by the target task processing node. The update task processing node refers to the task processing node used to reprocess the failed construction subtask. The target construction subtask refers to the construction subtask that fails to be processed, that is, the construction subtask processed by the failed target task processing node.

Based on this, in order to facilitate the traceback of building subtasks, after sending the processing node identification information of the target task processing node to the target task scheduling node, the processing node information of the target task processing node is sent to the target task traceback node. Moreover, the target task scheduling node also sends each construction subtask and the processing node identification information corresponding to each construction subtask to the target task backtracking node; if the processing result information returned by the failed target task processing node is not received within the preset time period , constructing a subtask query request based on the target processing node identification information of the failed target task processing node, and sending the subtask query request to the target task backtracking node.

Based on the target processing node identification information in the subtask query request, the target task backtracking node queries the target construction subtask corresponding to the failed target task processing node, and sends the target construction subtask to the device management node 304, and the device management node 304 Receive the target construction subtask corresponding to the task query request returned by the target task backtracking node. In the task processing node set associated with the task processing sub-service, determine the update task processing node corresponding to the target construction sub-task; and send the target construction sub-task to the update task processing node, so that the target can be constructed by the update task processing node Subtasks perform task processing.

For example: when the target task processing node is h_Node3 and the target task processing node h_Node4, the processing node identification information h_Node3001 of the target task processing node h_Node3 and the processing node identification information h_Node4002 of the target task processing node h_Node4 are sent to the subtask associated with the task backtracking The target task backtracks to node r_Node. The target task backtracking node r_Node receives the identification information of the two processing nodes and stores the identification information of the two processing nodes.

In addition, the target task scheduling node d_Node sends the construction subtask sT1 and the processing node identification information h_Node3001 corresponding to the construction subtask sT1 to the target task backtracking node r_Node, and constructs the subtask sT2 and the processing node identification information h_Node4002 corresponding to the construction subtask sT2 Send to the target task backtracking node r_Node.

The device management node does not receive the processing result information returned by the target task processing node h_Node3 within 10 minutes, then the target task processing node h_Node3 is regarded as the failed target task processing node, and based on the target processing node identification information of the failed target task processing node h_Node3 h_Node3001 constructs a subtask query request sq, and sends the subtask query request sq to the target task backtracking node r_Node. The target task backtracking node r_Node is queried based on the target processing node identification information h_Node3001 in the subtask query request sq, and the target construction subtask corresponding to the target processing node identification information h_Node3001 is determined as sT1, and the target construction subtask sT1 is sent to The device management node 304, the device management node 304 determines that the update task processing node corresponding to the target construction subtask sT1 is: task processing node h_Node5, then sends the target construction subtask sT1 to the task processing node h_Node5, so that the task processing node h_Node5 can The target constructs the subtask file list carried by the subtask sT1 to pull the files.

To sum up, through the backtracking process of the failed target task processing node, the target construction subtask corresponding to the failed target task processing node is determined, and the target construction subtask is sent to the update task processing node for reprocessing, realizing the target construction of the failed processing node Subtasks replace task processing nodes to ensure the robustness of the release package construction task.

In practical applications, considering the security of communication between device nodes, the sub-service set may also include a task security sub-service, and the task security sub-service is associated with a task security node set. The node management system 300 also includes: task security node;

The task safety node is configured to receive the node attribute information submitted by the registration node; determine node authentication association information based on the node attribute information, and generate a communication token based on the node authentication association information, and transfer the The communication token is sent to the device node, wherein the communication token is used to perform security authentication on the device node during inter-device communication.

Specifically, the task security node refers to a device node for providing task security sub-services. The task security sub-service refers to a sub-service that provides security authentication for communication between nodes. The task security node can perform verification such as host registration information verification, signature verification, IP verification, and game whitelist verification. Node authentication association information refers to information used to generate communication tokens, such as node name, IP address and other information. The communication token can be understood as the node authentication issued by the task safety node for the device node.

Based on this, after the registration node receives the node attribute information of the device node, it can send the node attribute information to the task safety node, and the task safety node can directly extract the node authentication association information from the node attribute information, and associate the node authentication The information is encrypted using a preset encryption algorithm to generate a communication token and send the communication token to the device node. When the device node communicates with other device nodes, it can carry the communication token in the communication request so that the communication peer It can be authenticated based on a communication token.

Assume that the node attribute information info of the device node SERVER1 also includes an IP address and a service name. After receiving the node attribute information info, the task security node s_Node extracts the IP address and service name in the node attribute information info, and uses The hash algorithm is encrypted to generate a communication token Token, and the communication token Token is sent to the device node SERVER1.

To sum up, the communication token is sent to the device node through the task security node, which realizes the secure communication between the device nodes and ensures the security during the execution of the release package construction task.

Optionally, the device management node 304 is further configured to:

Delete the target association relationship between the failed target task processing node and the task processing sub-service.

Optionally, the device management node 304 is further configured to:

Send the service startup script corresponding to the target sub-service to the device node; in the case of receiving the startup success information sent by the device node in response to the service startup script, execute the The service attribute information of the target sub-service establishes an association relationship between the device node and the target sub-service, and serves as a response step to the node allocation request.

Optionally, the device management node 304 is further configured to:

Sending a state detection instruction to the device node, and receiving detection information corresponding to the state detection instruction, and deleting the association relationship in response to the abnormality detection information when the detection information is abnormality detection information; and/or or,

receiving the abnormal reporting information reported by the device node, and deleting the association relationship in response to the abnormal reporting information.

Optionally, the device management node 304 is further configured to:

Determine the set of task processing nodes associated with the task processing sub-service, and determine the number of subtasks corresponding to the task processing nodes in the set of task processing nodes;

Sorting the task processing nodes in the task processing node set according to the subtask processing quantity, and screening the target task processing nodes associated with the subtask information in the task processing node set according to the sorting result.

The specific implementation of the device management node 304 in the above embodiment is similar to the specific implementation of the device management node in the above method embodiment, just refer to the specific implementation in the above method embodiment, and will not be repeated here.

Specifically, as shown in the system architecture diagram of the release package construction task shown in Figure 4, in order to ensure the efficiency and stability of the execution process of the release package construction task, registration services, node management services, and distributed resource management are required. The services cooperate with each other to complete the construction of the release package. Among them, the registration service provides the service of registering the device node to the device management node, and the registration service provides corresponding service functions by the registration node; the node management service provides service functions such as registration (assignment) and status inspection of the device node. The above-mentioned device management nodes provide corresponding service functions for management services; distributed resource management services provide service functions such as storage and distribution of resource files, and distributed resource management services should be provided by the above-mentioned preset resource management nodes.

Further, the node management service also includes 5 sub-services, which are task scheduling sub-service, task processing sub-service, task aggregation sub-service, task backtracking sub-service and task security sub-service. Among them, the task scheduling sub-service provides service functions such as splitting the release package construction task and initiating task scheduling requests. The task scheduling sub-service is provided by its associated task scheduling node with corresponding service functions; the task processing sub-service provides the split The task processing sub-service is provided by its associated task processing node; the task aggregation sub-service provides the service function of aggregating the task intermediate products generated in the task processing node , the task aggregation sub-service provides the corresponding service function by its associated task aggregation node; the task backtracking sub-service provides the service function of backtracking other services and the processing process associated with the sub-service, and the task backtracking sub-service is provided by its associated task The backtracking node provides the corresponding service function; the task security sub-service provides the service function of communication authentication for other services and the device nodes associated with the sub-service, and the task security sub-service is provided by its associated task security node with the corresponding service function; need to explain The number of device nodes (registration nodes, device management nodes, task scheduling nodes, task processing nodes, task aggregation nodes, task backtracking nodes, and preset resource management nodes) associated with the above-mentioned various services and sub-services is at least one. In addition, the implementation of the release package construction task can also rely on external services such as resource synchronization and package management. The resource synchronization is used to synchronize the updated resource files to the preset resource management nodes associated with the distributed management service. Package management, used to manage the type and version of the built release package.

The node management system 300 provided by this application cooperates with the device management node 304 through the registration node 302 in order to make the device nodes be reasonably utilized. The registration node 302 is configured to receive the node attribute information submitted by the device node, based on the node The attribute information constructs a node allocation request, and sends the node allocation request to the device management node 304; realizes initiating a node allocation request to the device node; the device management node 304 is configured to receive a node allocation request carrying node attribute information, wherein the node attribute The information corresponds to the device node, and the node attribute information is matched with the filter conditions corresponding to the sub-service set, and then the target sub-service corresponding to the device node is determined in the sub-service set according to the matching result, and the node Attribute information, to match it with a suitable target sub-service; and based on the node attribute information and the service attribute information of the target sub-service, establish an association relationship between the device node and the target sub-service, and use it as a response to the node allocation request, so that Use this device node to provide the service function corresponding to the target sub-service.

The node management system provided by this application, in order to make the device nodes be reasonably utilized, through the registration node 302, receives the node attribute information submitted by the device node, constructs a node allocation request based on the node attribute information, and sends the node allocation request Send it to the device management node 304; and receive the node assignment request carrying the node attribute information through the device management node 304, and match the node attribute information with the filter conditions corresponding to the sub-service set; according to the matching result in the sub-service Determine the target sub-service corresponding to the device node in the service set; establish an association relationship between the device node and the target sub-service based on the node attribute information and the service attribute information of the target sub-service, and use it as The node allocates the response to the request. According to the node attribute information of the device node itself, it is matched with the appropriate target sub-service, so that the device node can be used to provide the service function corresponding to the target sub-service, which not only ensures the adaptability between the target sub-service and the device node, The processing efficiency of the target sub-service is also guaranteed.

The foregoing is a schematic solution of a node management system in this embodiment. It should be noted that the technical solution of the node management system and the above-mentioned technical solution of the node management method belong to the same concept, and details of the technical solution of the node management system that are not described in detail can be found in the description of the technical solution of the above-mentioned node management method .

Corresponding to the foregoing method embodiments, the present application also provides an embodiment of a package construction system. FIG. 5 shows a schematic structural diagram of a package construction system provided by an embodiment of the present application. As shown in Figure 5, the package construction system 500 includes:

target task scheduling node 502, device management node 504, target task processing node 506 and target task aggregation node 508,

Wherein, the target task scheduling node 502 is configured to receive the release package construction task, split the release package construction task into construction subtasks, and build a task scheduling request based on the construction subtasks, and divide the task A dispatch request is sent to the device management node 504;

The device management node 504 is configured to, in response to the task scheduling request, determine the target task processing node 506 corresponding to the construction subtask, and send the processing node identification information of the target task processing node 506 to the The target task scheduling node 502, wherein the target task processing node 506 is determined in the task processing node set associated with the task processing sub-service in the sub-service set, and the task processing sub-service is determined according to the target task processing node 506 The matching result of the node attribute information and the filter condition corresponding to the sub-service set is determined in the sub-service set;

The target task scheduling node 502 is further configured to send the construction subtask corresponding to the release package construction task to the target task processing node 506 based on the identification information of the processing node;

The target task processing node 506 is configured to pull the sub-release file set corresponding to the construction sub-task, and push the sub-release file set to the target task aggregation node 508;

The target task aggregation node 508 is configured to construct a target release package corresponding to the release package construction task based on the received sub-release file set.

Optionally, the device management node 504 is further configured to receive a scheduling node request associated with a task of publishing a package construction, and determine a target task scheduling node 502 associated with a task scheduling sub-service in the sub-service set based on the scheduling node request ; and send the scheduling node identification information of the target task scheduling node 502 to the task requesting node corresponding to the scheduling node request;

The target task scheduling node 502 is further configured to receive the release package construction task submitted by the task request node.

Optionally, the target task scheduling node 502 is further configured to build a task scheduling request based on the subtask information associated with the build subtask corresponding to the release package build task;

Correspondingly, the device management node 504 is further configured to parse the task scheduling request to obtain subtask information corresponding to the release package construction task; based on the subtask information, in the subservice set The target task processing node 506 is determined in the task processing node set associated with the task processing sub-service.

Optionally, the target task processing node 506 is further configured to send processing result information to the device management node 504 when the pulling is completed;

The device management node 504 is further configured to receive the processing result information returned by the target task processing node 506, and determine the task intermediate result of the release package construction task based on the processing result information; in the task intermediate result If the processing is successful, determine the target task aggregation node 508 corresponding to the release package construction task in the task aggregation node set associated with the task aggregation sub-service in the sub-service set, and set the target task aggregation node 508 The aggregation node identification information is sent to each target task processing node 506 .

Optionally, the target task scheduling node 502 is further configured to acquire release package information carried by the release package construction task; determine a task file list based on the release package information;

According to a preset splitting strategy, the task file list is split into subtask file lists, and corresponding construction subtasks are constructed based on each subtask file list.

The target task processing node 506 is further configured to pull the sub-published file set corresponding to the sub-task file list from a preset resource management node according to the sub-task file list carried by the construction sub-task.

Optionally, the target task aggregation node 508 is further configured to construct the target release package corresponding to the release package construction task based on the received set of sub-release files, and generate aggregation result information according to the construction result, and convert the The aggregation result information is sent to the device management node 504;

The device management node 504 is further configured to receive the aggregation result information returned by the target task aggregation node 508, and determine the task construction result of the release package construction task based on the aggregation result information.

Optionally, the package construction system further includes: a target task backtracking node;

The device management node 504 is further configured to send the processing node identification information to the target task backtracking node associated with the task backtracking sub-service in the sub-service set;

The target task scheduling node 502 is further configured to send each construction subtask and the processing node identification information corresponding to each construction subtask to the target task backtracking node;

In the case that the processing result information returned by any target task processing node 506 is not received within the preset time length, any target task processing node 506 is regarded as a failed target task processing node 506, and the device management node 504 is also configured as Determine the target processing node identification information of the failed target task processing node 506; construct a subtask query request based on the target processing node identification information, and send the subtask query request to the target task backtracking node;

The target task backtracking node is configured to query the target construction subtask corresponding to the failed target task processing node 506 based on the target processing node identification information carried in the subtask query request, and send the target construction subtask to Device management node 504;

The device management node 504 is further configured to receive the target construction subtask corresponding to the subtask query request returned by the target task backtracking node; in the task processing node set associated with the task processing sub-service, determine the an update task processing node corresponding to the target construction subtask, and send the target construction subtask to the update task processing node.

Optionally, the package construction system further includes: a registration node;

The registration node is configured to receive node attribute information submitted by the target task processing node 506, construct a node allocation request based on the node attribute information, and send the node allocation request to the device management node 504;

The device management node 504 is configured to receive a node allocation request carrying node attribute information, match the node attribute information with the filter conditions corresponding to the sub-service set; The task processing sub-service corresponding to the target task processing node 506; based on the node attribute information and the service attribute information of the task processing sub-service, establish an association between the target task processing node 506 and the task processing sub-service relationship, and as a response to the node assignment request.

Optionally, the package construction system also includes: a task safety node;

The task security node is configured to receive the node attribute information submitted by the registration node; determine node authentication association information based on the node attribute information, and generate a communication token based on the node authentication association information, and transfer the The communication token is sent to the target task processing node 506, wherein the communication token is used to perform security authentication on the target task processing node 506 during inter-device communication.

Optionally, the device management node 504 is further configured to delete the target association relationship between the failed target task processing node 506 and the task processing sub-service.

Optionally, the device management node 504 is further configured to send the service startup script corresponding to the task processing sub-service to the target task processing node 506; In the case of the start-up success information sent by the script, execute the association between the target task processing node 506 and the task processing sub-service based on the node attribute information and the service attribute information of the task processing sub-service relationship, and as a response to the node assignment request.

Optionally, the device management node 504 is further configured to send a state detection instruction to the D node, and receive detection information corresponding to the state detection instruction, and when the detection information is abnormal detection information, deleting the association relationship in response to the anomaly detection information; and/or,

receiving the abnormal reporting information reported by the target task processing node 506, and deleting the association relationship between the target task processing node 506 and the task processing sub-service in response to the abnormal reporting information.

Optionally, the device management node 504 is further configured to determine a set of task processing nodes associated with the task processing sub-service, and determine the number of subtasks corresponding to the task processing nodes in the set of task processing nodes;

According to the subtask processing quantity, sort the task processing nodes in the task processing node set, and filter the target task processing node 506 associated with the subtask information in the task processing node set according to the sorting result.

To sum up, the package construction system provided by the embodiment of this specification cooperates through the target task scheduling node 502, the device management node 504, the target task processing node 506 and the target task aggregation node 508, wherein the target task scheduling node 502 is It is configured to receive the release package construction task, split the release package construction task into construction subtasks, construct a task scheduling request based on the construction subtasks, and send the task scheduling request to the device management node 504, realizing the construction after splitting The subtask applies for a target task processing node for task processing; the device management node 504 is configured to determine the target task processing node 506 corresponding to the construction subtask in response to the task scheduling request, and assign the processing node of the target task processing node 506 The identification information is sent to the target task scheduling node 502, wherein the target task processing node 506 is determined in the task processing node set associated with the task processing sub-service in the sub-service set, and the task processing sub-service is a node according to the target task processing node 506 The matching result of the attribute information and the filter condition corresponding to the sub-service set is determined in the sub-service set, which guarantees the processing capability of the target task processing node for task processing; the target task scheduling node 502 is also configured to process based on Node identification information, send the construction subtask corresponding to the release package construction task to the target task processing node 506; the target task processing node 506 is configured to pull the sub-release file set corresponding to the build sub-task, and push the sub-release file set to the target The task aggregation node 508; the target task aggregation node 508 is configured to construct the target release package corresponding to the release package construction task based on the received sub-release file set, and implement task processing based on the construction of sub-tasks, thereby improving task processing efficiency .

The foregoing is a schematic solution of a package construction system in this embodiment. It should be noted that the technical solution of the package construction system and the technical solution of the above-mentioned node management system belong to the same concept. For details not described in detail in the technical solution of the package construction system, please refer to the description of the technical solution of the above-mentioned node management system .

Corresponding to the above-mentioned system embodiment, the present application also provides an embodiment of a package construction method. FIG. 6 shows a flow chart of a package construction method provided by an embodiment of the present application. The package construction method specifically includes the following steps :

Step 602: Receive the release package construction task, and split the release package construction task into construction subtasks;

Step 604: Determine the target task processing node corresponding to the construction subtask, and send the construction subtask to the target task processing node, wherein the target task processing node is the task processing subservice in the subservice set Determined in the associated task processing node set, the task processing sub-service is determined in the sub-service set according to the matching result of the node attribute information of the target task processing node and the filter condition corresponding to the sub-service set of;

Step 606: Receive the sub-release file set returned by the target task processing node based on the construction sub-task;

Step 608: Construct the target release package corresponding to the release package construction task based on the set of sub-release files.

Optionally, the determining the target task processing node corresponding to the construction subtask includes:

Based on the subtask information corresponding to the construction subtask, the target task processing node is determined in the task processing node set associated with the task processing subservice in the subservice set.

Optionally, the splitting the publishing package building task into building subtasks includes:

Acquiring the release package information carried by the release package construction task;

determining a task file list based on the release package information;

According to a preset splitting strategy, the task file list is split into subtask file lists, and corresponding construction subtasks are constructed based on each subtask file list.

Optionally, after determining the target task processing node corresponding to the construction subtask, the method further includes:

Send each construction subtask and the processing node identification information corresponding to each construction subtask to the target task backtracking node;

After sending the construction subtask to the target task processing node, it also includes:

If the processing result information returned by any target task processing node is not received within the preset time period, any target task processing node is regarded as a failed target task processing node;

Determine the target processing node identification information of the failed target task processing node;

Constructing a subtask query request based on the target processing node identification information, and sending the subtask query request to the target task backtracking node;

receiving the target construction subtask corresponding to the subtask query request returned by the target task backtracking node;

In the task processing node set associated with the task processing sub-service, determine the update task processing node corresponding to the target construction sub-task, and send the target construction sub-task to the update task processing node.

Optionally, after setting any target task processing node as the failed target task processing node, the method further includes: deleting the target association relationship between the failed target task processing node and the task processing sub-service.

Optionally, the package construction method also includes:

receiving node attribute information of the target task processing node;

Determine node authentication association information based on the node attribute information, and generate a communication token based on the node authentication association information, and send the communication token to the target task processing node, wherein the communication token is used in Security authentication is performed on the target task processing node during inter-device communication.

Optionally, the package construction method also includes:

receiving a node assignment request carrying the node attribute information, and matching the node attribute information with the filter conditions corresponding to the sub-service set;

determining the task processing sub-service corresponding to the target task processing node in the sub-service set according to the matching result;

Based on the node attribute information and the service attribute information of the task processing sub-service, establish an association relationship between the target task processing node and the task processing sub-service, and use it as a response to the node allocation request.

Optionally, after determining the task processing sub-service corresponding to the target task processing node in the sub-service set according to the matching result, the method further includes:

sending a service startup script corresponding to the task processing sub-service to the target task processing node;

In the case of receiving the startup success information sent by the task processing node in response to the service startup script, execute the service attribute information based on the node attribute information and the task processing sub-service, and create the target task Processing the association relationship between the node and the task processing sub-service, as a response step of the node allocation request.

Optionally, the package construction method also includes:

Sending a state detection instruction to the target task processing node, and receiving detection information corresponding to the state detection instruction, and deleting the association relationship in response to the abnormal detection information when the detection information is abnormal detection information; and / or,

receiving the abnormal reporting information reported by the target task processing node, and deleting the association relationship in response to the abnormal reporting information.

Optionally, based on the subtask information corresponding to the construction subtask, determining the target task processing node in the task processing node set associated with the task processing subservice in the subservice set includes:

Determine the set of task processing nodes associated with the task processing sub-service, and determine the number of subtasks corresponding to the task processing nodes in the set of task processing nodes;

Sorting the task processing nodes in the task processing node set according to the subtask processing quantity, and screening the target task processing nodes associated with the subtask information in the task processing node set according to the sorting result.

To sum up, the package construction method provided by the embodiment of this specification splits the release package construction task into construction subtasks by receiving the release package construction task; determines the target task processing node corresponding to the construction subtasks, and divides the construction subtasks Send it to the target task processing node, and implement the target task processing node for the split construction subtask application for task processing, where the target task processing node is the task processing node associated with the task processing sub-service in the sub-service set Determined in the set, the task processing sub-service is determined in the sub-service set according to the matching result of the node attribute information of the target task processing node and the filter conditions corresponding to the sub-service set, which guarantees the goal of task processing The processing capability of the task processing node; and receive the sub-release file set returned by the target task processing node based on the construction of the sub-task, build the release package based on the sub-release file set and build the target release package corresponding to the task, and realize task processing based on the construction of sub-tasks, Thereby improving the task processing efficiency.

The foregoing is a schematic solution of a package construction method in this embodiment. It should be noted that the technical solution of the package construction method and the above-mentioned technical solution of the node management system belong to the same concept, and details not described in detail in the technical solution of the package construction system can be found in the description of the technical solution of the above-mentioned node management system .

FIG. 7 shows a structural block diagram of a computing device 700 provided according to an embodiment of the present application. Components of the computing device 700 include, but are not limited to, memory 710 and processor 720 . The processor 720 is connected to the memory 710 through the bus 730, and the database 750 is used for storing data.

Computing device 700 also includes an access device 740 that enables computing device 700 to communicate via one or more networks 760 . Examples of these networks include a public switched telephone network (PSTN, Public Switched Telephone Network), a local area network (LAN, Local Area Network), a wide area network (WAN, Wide Area Network), a personal area network (PAN, Personal Area Network) or a communication network such as the Internet The combination. The access device 740 may include one or more of wired or wireless network interfaces of any type (for example, a network interface card (NIC, network interface controller)), such as an IEEE802.11 wireless local area network (WLAN, Wireless Local Area Network) wireless interface , Worldwide Interoperability for Microwave Access (Wi-MAX, Worldwide Interoperability for Microwave Access) interface, Ethernet interface, Universal Serial Bus (USB, Universal Serial Bus) interface, cellular network interface, Bluetooth interface, near field communication (NFC, Near FieldCommunication ) interface, and so on.

In an embodiment of the present application, the above-mentioned components of the computing device 700 and other components not shown in FIG. 7 may also be connected to each other, for example, through a bus. It should be understood that the structural block diagram of the computing device shown in FIG. 7 is only for the purpose of illustration, rather than limiting the scope of the application. Those skilled in the art can add or replace other components as needed.

Computing device 700 can be any type of stationary or mobile computing device, including mobile computers or mobile computing devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile telephones (e.g., smartphones), ), wearable computing devices (eg, smart watches, smart glasses, etc.) or other types of mobile devices, or stationary computing devices such as desktop computers or personal computers (PC, Personal Computer). Computing device 700 may also be a mobile or stationary server.

Wherein, the processor 720 is configured to execute computer-executable instructions of the node management method.

The foregoing is a schematic solution of a computing device in this embodiment. It should be noted that the technical solution of the computing device and the above-mentioned technical solution of the node management method belong to the same concept, and details not described in detail in the technical solution of the computing device can refer to the description of the technical solution of the above-mentioned node management method.

An embodiment of the present application also provides a computer-readable storage medium, which stores computer instructions, and the instructions are used for the node management method when executed by a processor.

The foregoing is a schematic solution of a computer-readable storage medium in this embodiment. It should be noted that the technical solution of the storage medium and the above-mentioned technical solution of the node management method belong to the same idea, and details not described in detail in the technical solution of the storage medium can refer to the description of the technical solution of the above-mentioned node management method.

The computer instructions include computer program code, which may be in source code form, object code form, executable file or some intermediate form or the like. The computer-readable medium may include: any entity or device capable of carrying the computer program code, a recording medium, a U disk, a removable hard disk, a magnetic disk, an optical disk, a computer memory, and a read-only memory (ROM, Read-Only Memory) , Random Access Memory (RAM, Random Access Memory), electrical carrier signal, telecommunication signal, and software distribution medium, etc. It should be noted that the content contained in the computer-readable medium may be appropriately increased or decreased according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, computer-readable media Excludes electrical carrier signals and telecommunication signals.

An embodiment of the present application also provides a chip, which stores a computer program, and when the computer program is executed by the chip, the steps of the node management method are implemented.

It should be noted that, for the sake of simplicity of description, the aforementioned method embodiments are expressed as a series of action combinations, but those skilled in the art should know that the present application is not limited by the described action sequence. Depending on the application, certain steps may be performed in other orders or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by this application.

In the above-mentioned embodiments, the descriptions of each embodiment have their own emphases, and for parts not described in detail in a certain embodiment, reference may be made to relevant descriptions of other embodiments.

The preferred embodiments of the present application disclosed above are only used to help clarify the present application. Alternative embodiments are not exhaustive in all detail, nor are the inventions limited to specific implementations described. Obviously, many modifications and changes can be made according to the content of this application. This application selects and specifically describes these embodiments in order to better explain the principles and practical applications of this application, so that those skilled in the art can well understand and use this application. This application is to be limited only by the claims, along with their full scope and equivalents.

Claims (14)

1. A node management method, applied to a device management node, comprising:

receiving a node allocation request carrying node attribute information, wherein the node attribute information corresponds to a device node;

matching the node attribute information with screening conditions corresponding to the sub-service sets;

determining a target sub-service corresponding to the equipment node in the sub-service set according to the matching result;

and establishing an association relationship between the equipment node and the target sub-service based on the node attribute information and the service attribute information of the target sub-service, and taking the association relationship as a response of the node allocation request.

2. The method according to claim 1, wherein after determining the target sub-service corresponding to the device node in the sub-service set according to the matching result, the method further comprises:

sending a service start script corresponding to the target sub-service to the equipment node;

and under the condition that the equipment node receives the starting success information sent by responding to the service starting script, executing the service attribute information based on the node attribute information and the target sub-service, establishing the association relationship between the equipment node and the target sub-service, and taking the association relationship as a response step of the node allocation request.

3. The method as recited in claim 1, further comprising:

transmitting a state detection instruction to the equipment node, receiving detection information corresponding to the state detection instruction, and deleting the association relation in response to the abnormality detection information when the detection information is the abnormality detection information; and/or the number of the groups of groups,

and receiving abnormal report information reported by the equipment node, and deleting the association relation in response to the abnormal report information.

4. The method as recited in claim 1, further comprising:

receiving a scheduling node request associated with a task constructed by a release packet, and determining a target task scheduling node in a task scheduling node set associated with a task scheduling sub-service in the sub-service set based on the scheduling node request;

transmitting the scheduling node identification information of the target task scheduling node to a task request node corresponding to the scheduling node request;

receiving a task scheduling request sent by the target task scheduling node based on the issuing package construction task;

determining a target task processing node in a task processing node set associated with task processing sub-services in the sub-service set based on the task scheduling request, and sending processing node identification information of the target task processing node to the target task scheduling node;

And receiving processing result information returned by the target task processing node, and determining a task intermediate result of the issuing package construction task based on the processing result information.

5. The method of claim 4, wherein determining a target task processing node from a set of task processing nodes associated with a task processing sub-service in the set of sub-services based on the task scheduling request, comprises:

analyzing the task scheduling request to obtain subtask information corresponding to the issuing package construction task;

and determining a target task processing node in a task processing node set associated with a task processing sub-service in the sub-service set based on the sub-task information.

6. The method of claim 5, further comprising, after said sending the processing node identification information of the target task processing node to the target task scheduling node:

transmitting the processing node identification information to a target task backtracking node associated with a task backtracking sub-service in the sub-service set;

under the condition that processing result information returned by any one target task processing node is not received within a preset duration, taking any one target task processing node as a failed target task processing node, wherein the node management method further comprises the following steps:

Determining target processing node identification information of the failed target task processing node;

constructing a subtask query request based on the target processing node identification information, sending the subtask query request to the target task backtracking node, and receiving a target construction subtask corresponding to the subtask query request returned by the target task backtracking node;

and determining an updated task processing node corresponding to the target construction subtask in the task processing node set associated with the task processing subtask, and sending the target construction subtask to the updated task processing node.

7. The method as recited in claim 6, further comprising:

and deleting the target association relationship between the failed target task processing node and the task processing sub-service.

8. The method according to claim 4, wherein, in a case where a plurality of target task processing nodes are provided, after determining the task intermediate result of the publishing packet construction task based on the processing result information, further comprising:

under the condition that the task intermediate result is that the processing is successful, determining a target task aggregation node corresponding to the issuing package construction task in a task aggregation node set associated with task aggregation sub-services in the sub-service set, and sending aggregation node identification information of the target task aggregation node to each target task processing node;

And receiving the aggregation result information returned by the target task aggregation node, and determining a task construction result of the release packet construction task based on the aggregation result information.

9. The method of claim 5, wherein determining a target task processing node from a set of task processing nodes associated with a task processing sub-service in the set of sub-services based on the sub-task information, comprises:

determining a task processing node set associated with the task processing sub-service, and determining the subtask processing quantity corresponding to the task processing nodes in the task processing node set;

and sequencing the task processing nodes in the task processing node set according to the subtask processing quantity, and screening target task processing nodes associated with the subtask information in the task processing node set according to sequencing results.

10. A node management system, comprising:

registering the node and the equipment management node;

the registration node is configured to receive node attribute information submitted by a device node, construct a node allocation request based on the node attribute information, and send the node allocation request to the device management node;

The device management node is configured to receive a node allocation request carrying node attribute information, and match the node attribute information with screening conditions corresponding to the sub-service set; determining a target sub-service corresponding to the equipment node in the sub-service set according to the matching result; and establishing an association relationship between the equipment node and the target sub-service based on the node attribute information and the service attribute information of the target sub-service, and taking the association relationship as a response of the node allocation request.

11. A package build system, comprising:

a target task scheduling node, a device management node, a target task processing node and a target task aggregation node,

the target task scheduling node is configured to receive a release packet construction task, split the release packet construction task into construction subtasks, construct a task scheduling request based on the construction subtasks, and send the task scheduling request to the equipment management node;

the device management node is configured to respond to the task scheduling request, determine a target task processing node corresponding to the constructed subtask, and send processing node identification information of the target task processing node to the target task scheduling node, wherein the target task processing node is determined in a task processing node set associated with a task processing sub-service in a sub-service set, and the task processing sub-service is determined in the sub-service set according to a matching result of screening conditions corresponding to node attribute information of the target task processing node and the sub-service set;

The target task scheduling node is further configured to send a construction subtask corresponding to the release packet construction task to the target task processing node based on the processing node identification information;

the target task processing node is configured to pull a sub-release file set corresponding to the constructed sub-task and push the sub-release file set to the target task aggregation node;

the target task aggregation node is configured to construct a target release package corresponding to the release package construction task based on the received sub release file set.

12. A method of packet construction, comprising:

receiving a release packet construction task, and splitting the release packet construction task into construction subtasks;

determining a target task processing node corresponding to the constructed subtask, and sending the constructed subtask to the target task processing node, wherein the target task processing node is determined in a task processing node set associated with a task processing sub-service in a sub-service set, and the task processing sub-service is determined in the sub-service set according to a matching result of node attribute information of the target task processing node and screening conditions corresponding to the sub-service set;

Receiving a sub-release file set returned by the target task processing node based on the constructed sub-task;

and constructing a target release package corresponding to the release package construction task based on the sub release file set.

13. A computing device, comprising:

a memory and a processor;

the memory is configured to store computer executable instructions, and the processor is configured to execute the steps of the node management method according to any one of claims 1 to 9 or the packet construction method according to claim 12.

14. A computer readable storage medium storing computer instructions which, when executed by a processor, implement the node management method of any one of claims 1 to 9 or the steps of the packet construction method of claim 12.