CN117407139A - Method and device for reporting task execution result, storage medium and electronic equipment - Google Patents
Method and device for reporting task execution result, storage medium and electronic equipment Download PDFInfo
- Publication number
- CN117407139A CN117407139A CN202311403081.5A CN202311403081A CN117407139A CN 117407139 A CN117407139 A CN 117407139A CN 202311403081 A CN202311403081 A CN 202311403081A CN 117407139 A CN117407139 A CN 117407139A
- Authority
- CN
- China
- Prior art keywords
- task
- executed
- execution result
- result
- task execution
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 76
- 230000006870 function Effects 0.000 claims description 72
- 230000004044 response Effects 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 3
- 230000008569 process Effects 0.000 description 25
- 238000012360 testing method Methods 0.000 description 14
- 238000012545 processing Methods 0.000 description 8
- 238000010586 diagram Methods 0.000 description 6
- 230000001419 dependent effect Effects 0.000 description 4
- 239000002699 waste material Substances 0.000 description 4
- 241001522296 Erithacus rubecula Species 0.000 description 3
- 238000004891 communication Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000006978 adaptation Effects 0.000 description 2
- 125000004122 cyclic group Chemical group 0.000 description 2
- 238000003062 neural network model Methods 0.000 description 2
- 239000013307 optical fiber Substances 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 230000002123 temporal effect Effects 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 238000013527 convolutional neural network Methods 0.000 description 1
- 238000003066 decision tree Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 239000012634 fragment Substances 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 238000004064 recycling Methods 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 238000005096 rolling process Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The disclosure relates to a method and a device for reporting a task execution result, a storage medium and electronic equipment, and relates to the technical field of computers, wherein the method comprises the following steps: responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function; generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed; feeding back the result delay report mark to a task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay report mark; executing the task to be executed to obtain a task execution result, and feeding back the task execution result to the task scheduling center to realize asynchronous uploading of the task execution result. The method and the device realize asynchronous report of the task execution result.
Description
Technical Field
The embodiment of the disclosure relates to the technical field of computers, in particular to a method for reporting a task execution result, a device for reporting the task execution result, a computer-readable storage medium and electronic equipment.
Background
In the existing task execution scheme, a mode of synchronously reporting a task execution result is adopted; that is, after the task scheduling center issues the task to be executed to the task executor, the task scheduling center is in a state of waiting for the task executor to report the task execution result until the task execution result fed back by the task executor is received.
However, the above scheme has the following drawbacks: asynchronous reporting of task execution results is not supported.
It should be noted that the information of the present invention in the above background section is only for enhancing understanding of the background of the present disclosure, and thus may include information that does not form the prior art that is already known to those of ordinary skill in the art.
Disclosure of Invention
The disclosure aims to provide a method for reporting a task execution result, a device for reporting a task execution result, a computer-readable storage medium and an electronic device, so as to overcome the problem that asynchronous reporting of the task execution result is not supported due to the limitations and defects of the related art at least to a certain extent.
According to one aspect of the present disclosure, a method for reporting a task execution result is provided, configured to a task executor in a distributed task scheduling platform, where the method for reporting a task execution result includes:
Responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function;
generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed;
feeding back the result delay report mark to a task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay report mark;
executing the task to be executed to obtain a task execution result, and feeding back the task execution result to the task scheduling center to realize asynchronous uploading of the task execution result.
In an exemplary embodiment of the present disclosure, in response to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, invoking an execution result asynchronous reporting function, including:
responding to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, and determining task execution time required by executing the task to be executed;
judging whether the task execution time is longer than the preset task result waiting time set by the task scheduling center;
And when the task execution time is determined to be longer than the preset task result waiting time, calling an execution result asynchronous reporting function.
In one exemplary embodiment of the present disclosure, invoking an execution result asynchronous reporting function includes:
calling a byte code editing class library in the task executor, and defining byte codes to be compiled corresponding to the execution result asynchronous reporting function based on the byte code editing class library;
loading a Java virtual machine, compiling the byte code to be compiled based on the Java virtual machine to obtain the execution result asynchronous reporting function, and integrating the execution result asynchronous reporting function into a function library of the task executor;
and calling the execution result asynchronous reporting function from the function library.
In an exemplary embodiment of the present disclosure, determining a task execution time required to execute the task to be executed includes:
decomposing the task to be executed to obtain a subtask to be executed included in the task to be executed; wherein, the task to be executed at least comprises one subtask to be executed;
generating a task attribute label corresponding to the subtask to be executed according to the target computing power resource type and the target computing power demand capability required by the subtask to be executed;
Distributing a target task execution node for a subtask to be executed from current computing power nodes in the task executor based on the task attribute label, and acquiring the current computing power resource type and the current computing power supply capability of the target task execution node;
and determining task execution time required for executing the task to be executed according to the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity.
In one exemplary embodiment of the present disclosure, determining a task execution time required to execute the task to be executed according to the current computing power resource type, the current computing power supply capability, the target computing power resource type, and the target computing power demand capability includes:
inputting the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity into a preset time prediction model to obtain a time prediction result;
and determining task execution time required by executing the task to be executed according to the time prediction result.
In an exemplary embodiment of the present disclosure, executing the task to be executed to obtain a task execution result includes:
Issuing a subtask to be executed in the subtask to be executed to a target task execution node corresponding to the subtask to be executed, and executing the subtask to be executed through the target task execution node to obtain a task execution result.
In an exemplary embodiment of the present disclosure, executing the subtasks to be executed to obtain a task execution result includes:
acquiring task execution codes corresponding to the subtasks to be executed, and determining a container generation script required by executing the task execution codes according to the current code category of the task execution codes;
executing the container generation script to obtain a container task mirror image corresponding to the task execution code, and submitting the container task mirror image to a container orchestration engine;
and calling a task execution tool required for scheduling and executing the container task mirror image according to the current task category of the subtask to be executed by the container orchestration engine, and executing the container task mirror image by the task execution tool to obtain the task execution result.
According to one aspect of the present disclosure, there is provided a reporting device of a task execution result, configured to a task executor in a distributed task scheduling platform, the reporting device of the task execution result including:
The function calling module is used for responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function;
the result delay reporting mark generation module is used for generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed;
the result delay reporting mark feedback module is used for feeding back the result delay reporting mark to a task scheduling center so that the task scheduling center marks the task to be executed based on the result delay reporting mark;
and the task execution result feedback module is used for executing the task to be executed to obtain a task execution result and feeding the task execution result back to the task scheduling center so as to realize asynchronous uploading of the task execution result.
According to an aspect of the present disclosure, there is provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements a method of reporting a task execution result as described in any one of the above.
According to one aspect of the present disclosure, there is provided an electronic device including:
A processor; and
a memory for storing executable instructions of the processor;
the processor is configured to execute the reporting method of the task execution result according to any one of the above through executing the executable instruction.
According to the method for reporting the task execution result, on one hand, an execution result asynchronous reporting function is called by responding to a task to be executed issued by a task scheduling center in a distributed task scheduling platform; then, according to the execution result asynchronous reporting function and the current task identifier, generating a result delay reporting mark corresponding to the task to be executed; the result delay reporting mark is fed back to the task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay reporting mark; finally, executing the task to be executed to obtain a task execution result, and feeding back the task execution result to a task scheduling center to realize asynchronous uploading of the task execution result, thereby solving the problem that asynchronous reporting of the task execution result is not supported in the prior art; on the other hand, the task scheduling center can mark the task to be executed by the result delay report mark without waiting for the task execution result of the task to be executed, thereby solving the problem of resource waste of the task scheduling center caused by the fact that the task scheduling center needs to be always in a state of waiting for the task execution result reported by the task executor in the prior art.
It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the disclosure and together with the description, serve to explain the principles of the disclosure. It will be apparent to those of ordinary skill in the art that the drawings in the following description are merely examples of the disclosure and that other drawings may be derived from them without undue effort.
Fig. 1 schematically illustrates a flowchart of a method for reporting a task execution result according to an example embodiment of the present disclosure.
Fig. 2 schematically illustrates a block diagram of a reporting system of task execution results according to an example embodiment of the present disclosure.
Fig. 3 schematically illustrates an exemplary diagram of the structure of a task scheduling center according to an exemplary embodiment of the present disclosure.
Fig. 4 schematically illustrates a structural example diagram of a task executor according to an exemplary embodiment of the present disclosure.
FIG. 5 schematically illustrates a flow chart of a method for invoking an execution result asynchronous reporting function in response to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, according to an example embodiment of the present disclosure.
Fig. 6 schematically illustrates an example diagram of a container group Pod made up of multiple containers according to an example embodiment of the present disclosure.
Fig. 7 schematically illustrates a block diagram of a reporting apparatus of a task execution result according to an exemplary embodiment of the present disclosure.
Fig. 8 schematically illustrates an electronic device for implementing a reporting method of the task execution result according to an exemplary embodiment of the present disclosure.
Detailed Description
Example embodiments will now be described more fully with reference to the accompanying drawings. However, the exemplary embodiments may be embodied in many forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of the example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided to give a thorough understanding of embodiments of the present disclosure. One skilled in the relevant art will recognize, however, that the aspects of the disclosure may be practiced without one or more of the specific details, or with other methods, components, devices, steps, etc. In other instances, well-known technical solutions have not been shown or described in detail to avoid obscuring aspects of the present disclosure.
Furthermore, the drawings are merely schematic illustrations of the present disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus a repetitive description thereof will be omitted. Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in software or in one or more hardware modules or integrated circuits or in different networks and/or processor devices and/or microcontroller devices.
In some processes of task processing based on a distributed task scheduling platform, when a task scheduling center monitors a task to be executed, the task to be executed is issued to a task executor, after the task to be executed is issued, the task state of the task to be executed is marked as a task execution result waiting state, and then whether the task executor feeds back a corresponding task execution result is monitored by setting a thread mode. However, this method has the following drawbacks: the scheme can only support synchronous return of the task execution result, but not asynchronous return of the task execution result; that is, the task scheduling center needs to receive the task execution result within a certain time, otherwise, the task to be executed is considered to be failed to execute, and then the task to be executed is repeatedly issued, so that the problem of resource waste is caused by the repeated execution of the task to be executed.
Based on this, in this exemplary embodiment, a method for reporting a task execution result is provided first, where the method may operate on a server, a server cluster, or a cloud server where a task executor in a distributed task scheduling platform is located; of course, those skilled in the art may also operate the methods of the present disclosure on other platforms as desired, which is not particularly limited in the present exemplary embodiment. Specifically, referring to fig. 1, the method for reporting the task execution result may include the following steps:
s110, calling an execution result to asynchronously report a function in response to a task to be executed issued by a task scheduling center in a distributed task scheduling platform;
s120, generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier;
s130, feeding the result delay reporting mark back to a task scheduling center so that the task scheduling center marks the task to be executed based on the result delay reporting mark;
and S140, executing the task to be executed to obtain a task execution result, and feeding back the task execution result to the task scheduling center so as to realize asynchronous uploading of the task execution result.
In the method for reporting the task execution result, on one hand, an execution result asynchronous reporting function is called by responding to a task to be executed issued by a task scheduling center in a distributed task scheduling platform; then, according to the execution result asynchronous reporting function and the current task identifier, generating a result delay reporting mark corresponding to the task to be executed; the result delay reporting mark is fed back to the task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay reporting mark; finally, executing the task to be executed to obtain a task execution result, and feeding back the task execution result to a task scheduling center to realize asynchronous uploading of the task execution result, thereby solving the problem that asynchronous reporting of the task execution result is not supported in the prior art; on the other hand, the task scheduling center can mark the task to be executed by the result delay report mark without waiting for the task execution result of the task to be executed, thereby solving the problem of resource waste of the task scheduling center caused by the fact that the task scheduling center needs to be always in a state of waiting for the task execution result reported by the task executor in the prior art.
Hereinafter, a method for reporting a task execution result described in example embodiments of the present disclosure will be explained and described in detail with reference to the accompanying drawings.
First, a report system of task execution results according to an exemplary embodiment of the present disclosure is explained and explained. Specifically, referring to fig. 2, the reporting system of the task execution result may include a task scheduling center 210 and a task executor 220; the task scheduling center can be in communication connection with the task executor through a wired network or a wireless network. Further, the task scheduling center can be used for issuing the task to be executed and receiving the task execution result; the task executor may be used to implement the method for reporting the task execution result described in the exemplary embodiment of the present disclosure.
In an example embodiment, referring to FIG. 3, the task scheduling center described herein may include a task management module 301, an executor management module 302, a log management module 303, and other modules 304; the task management module 301 may be configured to manage tasks to be executed, and the executor management module 302 may be configured to manage each task executor, for example, manage registration of each task executor, an application name corresponding to each task executor, a machine address list of the task executor, and so on; the log management module 303 may be configured to manage a scheduling log, a Rolling log, and the like generated during task execution of a task to be executed; meanwhile, other modules 304 may be used to manage running reports, failure alarms, task dependencies, etc. generated during task execution.
In an example embodiment, referring to FIG. 4, a task executor may include a plurality of different categories of subtask executors, such as subtask executor 1, subtask executor 2, subtask executors 3, …, subtask executor n, and so on; the function types of each subtask executor may be the same or different, and the present example is not particularly limited.
Next, the technical implementation principle of the exemplary embodiments of the present disclosure will be explained and illustrated. Specifically, the reporting method of the task execution result recorded in the example embodiment of the present disclosure is applied to a distributed task scheduling platform in a task execution timing round robin scenario or in a single task execution scenario; in the actual application process, after the task scheduling center issues a timing round-robin task or a single task to the task executor, the task executor can feed back a mark (namely, a result delay report mark) of which the task execution result needs to be reported later to the task scheduling center, after the task scheduling center receives the mark of which the task execution result needs to be reported later, the task to be executed can be identified based on the mark, and the task to be executed is not continuously monitored; then, when the task executor completes execution of the task to be executed, uploading a task execution result to a task scheduling center; and after the task scheduling center receives the task execution result, canceling the delay reporting identification of the task to be executed, and marking that the task is completed. By the method, the probability of task execution failure caused by the fact that the task execution result is not reported in time can be reduced under the condition of reducing resource waste of the task scheduling center.
Hereinafter, a method for reporting the task execution result shown in fig. 1 will be further explained and illustrated with reference to fig. 2 to 4. Specific:
in step S110, an execution result asynchronous reporting function is called in response to a task to be executed issued by a task scheduling center in the distributed task scheduling platform.
Specifically, referring to fig. 5, in response to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, invoking an execution result asynchronous reporting function may include the following steps:
step S510, determining task execution time required for executing the task to be executed in response to the task to be executed issued by the task scheduling center in the distributed task scheduling platform.
Specifically, determining the task execution time required for executing the task to be executed may be implemented in the following manner: firstly, decomposing the task to be executed to obtain a subtask to be executed included in the task to be executed; wherein, the task to be executed at least comprises one subtask to be executed; secondly, generating a task attribute label corresponding to the subtask to be executed according to the target computing power resource type and the target computing power demand capability required by executing the subtask to be executed; then, distributing a target task execution node for the subtask to be executed from current computing force nodes in the task executor based on the task attribute label, and acquiring the current computing force resource type and the current computing force supply capability of the target task execution node; and finally, determining the task execution time required for executing the task to be executed according to the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity.
In an example embodiment, determining the task execution time required to execute the task to be executed according to the current computing power resource type, the current computing power supply capability, the target computing power resource type, and the target computing power demand capability may be implemented as follows: firstly, inputting the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity into a preset time prediction model to obtain a time prediction result; and secondly, determining task execution time required by executing the task to be executed according to the time prediction result.
Hereinafter, a specific determination process of the task execution time will be further explained and explained. Specifically, in the actual application process, when a task executor receives a task to be executed issued by a task scheduling center, the task to be executed can be analyzed to obtain one or more sub-tasks to be executed which need to be executed; then, generating a task attribute label corresponding to the subtask to be executed according to the target computing power resource type and the target computing power demand capability required by executing the subtask to be executed; the target computing power resource type described herein refers to a computing power resource type required for executing the subtasks to be executed, such as a CPU resource type or a GPU resource type or a memory resource type, etc.; the target computing power demand capability described herein refers to a CPU resource or a GPU resource or a memory resource, etc. required for executing the subtasks to be executed; meanwhile, a task attribute label needs to be generated so as to be matched in a node attribute label of a current computing node (the node attribute label is generated according to the current computing resource type and the current computing power supply capability of the current computing node) based on the task attribute label, and further the subtask to be executed can be quickly matched to a corresponding target task execution node; further, after the corresponding target task execution node is matched, the corresponding task execution time can be calculated based on the current computing power resource type and the current computing power supply capability of the target task execution node, and the target computing power resource type and the target computing power demand capability required by executing the subtasks to be executed.
Further, in the calculation process of the task execution time, the task execution time can be realized based on a corresponding network model; that is, the current computing power resource type and the current computing power supply capability of the target task execution node, and the target computing power resource type and the target computing power demand capability required by executing the subtasks to be executed can be input into the corresponding time prediction model, so that the task execution time can be obtained; the temporal prediction model described herein may include a convolutional neural network model, a cyclic neural network model, a deep neural network model, a decision tree model, and the like, and is not particularly limited in this example.
Step S520, determining whether the task execution time is longer than a preset task result waiting time set by the task scheduling center.
Specifically, after the task execution time is obtained, whether the task execution time is longer than the preset task result waiting time set by the task scheduling center can be judged; the preset task result waiting time described herein may be set according to actual needs, or may be obtained by prediction through a corresponding network model, which is not limited in this example. Meanwhile, in the practical application process, for a task to be executed with a short task execution time, the task to be executed can be directly realized in a mode of marking the task to be executed as a state of waiting for a task execution result, and after the task executor completes execution of the task to be executed, the corresponding task execution result can be fed back; by the mode, the communication times between the task executor and the task scheduling center can be reduced; of course, for a task to be executed with a long task execution time, identification is required.
And step S530, calling an execution result asynchronous reporting function when the task execution time is determined to be longer than the preset task result waiting time.
Specifically, the calling of the execution result asynchronous reporting function can be realized by the following modes: calling a byte code editing class library in the task executor, and defining byte codes to be compiled corresponding to the execution result asynchronous reporting function based on the byte code editing class library; loading a Java virtual machine, compiling the byte code to be compiled based on the Java virtual machine to obtain the execution result asynchronous reporting function, and integrating the execution result asynchronous reporting function into a function library of the task executor; and calling the execution result asynchronous reporting function from the function library. That is, in the process of practical application, editing and compiling of the execution result asynchronous reporting function can be realized based on a byte code editing class library (for example, java Programming Assistant); when the function needs to be called to realize asynchronous reporting of the execution result, the function can be called from a corresponding function library.
The method is characterized in that the execution result asynchronous reporting function is edited and compiled through a byte code editing class library, and the byte code editing class library can enable Java programs to be defined in running and compiled through JVM (Java Virtual Machine ), so that online modification of class messages is realized, online editing and calling of the result asynchronous reporting function are realized, and the purpose of improving the calling efficiency of the function is achieved.
In step S120, a result delay report flag corresponding to the task to be executed is generated according to the execution result asynchronous report function and the current task identifier of the task to be executed.
Specifically, in the actual application process, first, the current Task identifier of the Task to be executed may be obtained, and then the execution result asynchronous reporting function may be modified based on the Java virtual machine through the current Task identifier (the current Task identifier is also referred to as task_id), so as to obtain a result delay reporting flag corresponding to the Task to be executed. That is, the current task identifier may be added to the execution result asynchronous reporting function based on the Java virtual machine, so as to obtain a result delay reporting flag corresponding to the task to be executed.
In step S130, the result delay report flag is fed back to the task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay report flag.
Specifically, after the result delay reporting mark is obtained, the task executor can send the result delay reporting mark to the task scheduling center; after the task scheduling center receives the result delay reporting mark, the task to be executed can be marked based on the result delay reporting mark; meanwhile, if the task scheduling center detects the result delay reporting mark after detecting the task execution condition, the task to be executed is known to be still in the task execution process, and the task execution failure is not caused. Based on this mode, the problem that the task to be executed is directly considered to be failed in execution because the task execution result is not received for a long time can be avoided.
In step S140, the task to be executed is executed to obtain a task execution result, and the task execution result is fed back to the task scheduling center, so as to realize asynchronous uploading of the task execution result.
In this example embodiment, executing the task to be executed may obtain a task execution result, which may be implemented as follows: issuing a subtask to be executed in the subtask to be executed to a target task execution node corresponding to the subtask to be executed, and executing the subtask to be executed through the target task execution node to obtain a task execution result.
In an example embodiment, the executing the subtasks to be executed, to obtain a task execution result, may be implemented in the following manner: acquiring task execution codes corresponding to the subtasks to be executed, and determining a container generation script required by executing the task execution codes according to the current code category of the task execution codes; executing the container generation script to obtain a container task mirror image corresponding to the task execution code, and submitting the container task mirror image to a container orchestration engine; invoking a task execution tool required for scheduling and executing the container task mirror image by the container orchestration engine according to the current task category of the subtask to be executed; the current task category comprises single task execution and/or timing round robin task execution; and executing the container task mirror image through the task execution tool to obtain the task execution result.
In an example embodiment, invoking the task execution tool required to schedule execution of the container task image may be accomplished by: when the current task category of the task execution code is single task execution, determining that a task execution tool required for executing a container task image corresponding to the task execution code is a single task execution tool, and calling the single task execution tool required for scheduling and executing the container task image; when the current task category of the task execution code is the timing round robin task execution, determining a task execution tool required for executing the container task image corresponding to the task execution code as a circulation task execution tool, and calling the circulation task execution tool required for scheduling and executing the container task image.
Hereinafter, a specific execution process of the task to be executed will be further explained and illustrated. Specifically, first, a subtask to be executed in a task to be executed needs to be issued to a target task execution node corresponding to the subtask to be executed, and then the subtask to be executed is executed by the target task execution node, so as to obtain a task execution result. Secondly, in the process of executing the subtask to be executed, firstly determining a container generation script required by executing the task execution code according to the current code category of the task execution code; wherein, the container generation script is Dockerfile; further, in the actual application process, the specific determination process of the container generation script can be realized by the following modes: firstly, acquiring the current code name of a task execution code; wherein the current code name may include a name portion + a suffix portion; secondly, determining a programming language adopted by the task execution code according to the suffix part of the task execution code, and further determining the current code category of the task execution code based on the programming language; then, acquiring a corresponding container generation script based on the current code category; it should be noted that if the container generation script corresponding to the current code class exists in the database, the container generation script may be directly obtained; if not, a container generation script needs to be constructed; furthermore, the Dockerfile described herein is a file that may be used to construct a docker image, where the Dockerfile includes instructions required to construct the image, and has a specific grammar rule; therefore, in order to be able to execute a task corresponding to the task execution code, it is necessary to acquire or construct a container generation script corresponding to the task execution code, and then execute the corresponding task in the corresponding container; the tasks described herein may include a test task, a test case generation task, or the like, and the present example is not particularly limited.
In an example embodiment, the specific implementation process of constructing the container generation script is: firstly, inquiring target configuration information required by a construction container to generate a script; the target configuration information is preset in the database, where the target configuration information may include a current code type of the task execution code, a task execution frame type, an environment variable configuration, task execution data, and the like, and may also include other configuration information that needs to be used, which is not limited in this example. Secondly, after the target configuration information is queried, the executable image corresponding to the task execution code can be determined according to the current code type.
In one example embodiment, a specific determination of the executable image may be implemented as follows: firstly, judging whether the task execution code needs to be compiled or not according to the current code type; secondly, when the task execution code is determined to need compiling, pre-compiling the task execution code to obtain a first executable mirror image associated with the task execution code; or when the task execution code is determined not to need compiling, acquiring a second executable image corresponding to the task execution frame type corresponding to the task execution code. Further, in the specific generation process of the container generation script and the executable image, firstly, judging whether the task execution code needs to be compiled according to the current code type; if the script type is Java language or Go language, determining that compiling is needed; if compiling is needed, executing a precompiled constructing step to obtain a first executable mirror image; if compiling is not needed, the second executable image corresponding to the task execution framework type can be directly acquired. Further, after the executable image is obtained, the container generation script can be generated according to the target configuration information and the executable image. The specific generation process of the container generation script can be realized by the following steps: on the one hand, if the test script file needs to be compiled, generating the container generation script according to the first executable mirror image and the target configuration information; on the other hand, if the test script file does not need to be compiled, generating the container generation script according to the second executable image and the target configuration information; the container generation script can comprise target configuration information, a first executable image or a second executable image which are required by executing the task execution code; the target configuration information includes executing the task execution code, a current code class, a task execution framework type, an environment variable configuration, task execution data, and the like.
In one example embodiment, after obtaining the container generation script, the container generation script may be executed to obtain the container task image; specifically, in the process of executing a container generation script, firstly, an executable mirror image, a dependent software package, task execution data and a task execution code which are included in the container generation script are installed to a specified directory associated with the task execution code; and secondly, generating a container starting instruction according to the target configuration information, and generating a container task image based on the container starting instruction, the executable image under the designated directory, the dependent software package, the task execution data and the task execution code. That is, an executable image (a first executable image or a second executable image), a dependent software package, task execution data and task execution codes can be installed to a specified directory, and then corresponding container task images are generated according to a container starting instruction and the first executable image or the second executable image under the specified directory, the dependent software package, the task execution data and the task execution codes; further, after obtaining the container task image, the container task image may be uploaded to a container orchestration engine, where the container orchestration engine may be Kubernetes, and the container orchestration engine may be used as a task running environment, that is, in Kubernetes, may support the startup of the container image. Meanwhile, in the process of uploading the container task image to the container arranging engine, the container arranging engine judges whether the container task image is a repeated task according to the task name fragment of the container task image, if so, task submission is forbidden; if not, normal submitting is carried out.
In one example embodiment, after uploading the container task image to the container orchestration engine, the task execution tools required to schedule execution of the container task image may be invoked by the container orchestration engine according to the current task categories that the task execution code has. Specifically, in the process of calling the task execution tool, for single task execution, the single task execution tool Job may be called to perform task execution, and for timing round-robin task execution, the cyclic task execution tool CronJob in K8s may be called to perform task execution; the distinction from Job is: in actual execution of the CronJob executor, the task needs to be decomposed into one Job first, and the Job is finally decomposed into one Pod (container group), and the task execution is completed by the corresponding Pod. Further, after the corresponding task execution tool is called, the task mirror image of the container can be executed through the task execution tool, and a task execution result is obtained; the specific execution process of the subtasks to be executed is as follows: if the task is executed in a single time, a Pod can be allocated for the task image to be executed directly based on the Job task executor, and then the task image to be executed is executed in the Pod to obtain a corresponding task execution container; if the task is executed by the circulating task, decomposing the task image to be executed based on the CronJob task executor to obtain a task image to be executed currently, further distributing a Pod for the task image to be executed currently, executing the task image to be executed currently in the Pod, and further obtaining a corresponding task execution container. Further, after the task execution container is obtained, the task execution container can be executed, and the task execution result is obtained. Specifically, the specific execution process of the task execution container can be realized by the following modes: and starting and executing the executable mirror image included in the task execution container to obtain a task execution result. And deleting the executable image in the task execution container when the executable image included in the task execution container is determined to be executed. By the method, pod can be recycled, the purpose of recycling resources when the resources are used up and used down is achieved, and hardware cost is greatly reduced.
In an example embodiment, executing the task image to be executed results in a task execution container, which may include: configuring a container group consisting of a plurality of independent sub-containers in a container encoding engine; the independent sub-containers included in the container group comprise a plurality of interface test auxiliary containers, user interface test auxiliary containers, uploading/downloading containers and script execution containers; selecting a target container required by executing the mirror image to be executed from the container group according to the current code type, and executing the task mirror image to be executed in the target container to obtain a task execution container; wherein the interface test auxiliary container described herein is for executing container mirroring of an interface type test script object; the user interface auxiliary container is used for executing container mirror image of the test script object of the interactive interface type; the uploading/downloading container is used for dynamically downloading the test script file associated with the test script object or uploading the packaged test execution report in real time; the script execution container is used for responding to the updating operation of the test script file and updating the test script file; a specific example of a multi-container set is shown with reference to fig. 6.
Finally, after the task execution result is obtained, the task execution result can be fed back to the task scheduling center, and when the task scheduling center receives the corresponding task execution result, the current task state of the task to be executed can be modified to be executed.
Up to this point, the method for reporting the task execution result described in the exemplary embodiment of the present disclosure has been fully implemented. Based on the foregoing description, it can be known that, in the method for reporting a task execution result according to the exemplary embodiment of the present disclosure, a mechanism for asynchronously delaying reporting the task execution result is implemented on a task executor side; the task scheduling center side can support the execution of tasks with asynchronously reported execution results.
The following are device embodiments of the present disclosure that may be used to perform method embodiments of the present disclosure. For details not disclosed in the embodiments of the apparatus of the present disclosure, please refer to the embodiments of the method of the present disclosure.
The example embodiment of the disclosure also provides a device for reporting the task execution result, which is configured in the task executor in the distributed task scheduling platform. Specifically, referring to fig. 7, the reporting device of the task execution result may include a function calling module 710, a result delay reporting flag generating module 720, a result delay reporting flag feedback module 730, and a task execution result feedback module 740. Wherein:
The function calling module 710 may be configured to respond to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and call an execution result asynchronous reporting function;
the result delay report flag generation module 720 may be configured to generate a result delay report flag corresponding to the task to be executed according to the execution result asynchronous report function and the current task identifier of the task to be executed;
the result delay reporting flag feedback module 730 may be configured to feedback the result delay reporting flag to a task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay reporting flag;
the task execution result feedback module 740 may be configured to execute the task to be executed to obtain a task execution result, and feed back the task execution result to the task scheduling center, so as to implement asynchronous uploading of the task execution result.
In an exemplary embodiment of the present disclosure, in response to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, invoking an execution result asynchronous reporting function, including: responding to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, and determining task execution time required by executing the task to be executed; judging whether the task execution time is longer than the preset task result waiting time set by the task scheduling center; and when the task execution time is determined to be longer than the preset task result waiting time, calling an execution result asynchronous reporting function.
In one exemplary embodiment of the present disclosure, invoking an execution result asynchronous reporting function includes: calling a byte code editing class library in the task executor, and defining byte codes to be compiled corresponding to the execution result asynchronous reporting function based on the byte code editing class library; loading a Java virtual machine, compiling the byte code to be compiled based on the Java virtual machine to obtain the execution result asynchronous reporting function, and integrating the execution result asynchronous reporting function into a function library of the task executor; and calling the execution result asynchronous reporting function from the function library.
In an exemplary embodiment of the present disclosure, determining a task execution time required to execute the task to be executed includes: decomposing the task to be executed to obtain a subtask to be executed included in the task to be executed; wherein, the task to be executed at least comprises one subtask to be executed; generating a task attribute label corresponding to the subtask to be executed according to the target computing power resource type and the target computing power demand capability required by the subtask to be executed; distributing a target task execution node for a subtask to be executed from current computing power nodes in the task executor based on the task attribute label, and acquiring the current computing power resource type and the current computing power supply capability of the target task execution node; and determining task execution time required for executing the task to be executed according to the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity.
In one exemplary embodiment of the present disclosure, determining a task execution time required to execute the task to be executed according to the current computing power resource type, the current computing power supply capability, the target computing power resource type, and the target computing power demand capability includes: inputting the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity into a preset time prediction model to obtain a time prediction result; and determining task execution time required by executing the task to be executed according to the time prediction result.
In an exemplary embodiment of the present disclosure, executing the task to be executed to obtain a task execution result includes: issuing a subtask to be executed in the subtask to be executed to a target task execution node corresponding to the subtask to be executed, and executing the subtask to be executed through the target task execution node to obtain a task execution result.
In an exemplary embodiment of the present disclosure, executing the subtasks to be executed to obtain a task execution result includes: acquiring task execution codes corresponding to the subtasks to be executed, and determining a container generation script required by executing the task execution codes according to the current code category of the task execution codes; executing the container generation script to obtain a container task mirror image corresponding to the task execution code, and submitting the container task mirror image to a container orchestration engine; and calling a task execution tool required for scheduling and executing the container task mirror image according to the current task category of the subtask to be executed by the container orchestration engine, and executing the container task mirror image by the task execution tool to obtain the task execution result.
The specific details of each module in the above-mentioned reporting device for the task execution result are described in detail in the corresponding reporting method for the task execution result, so that the details are not repeated here.
It should be noted that although in the above detailed description several modules or units of a device for action execution are mentioned, such a division is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit in accordance with embodiments of the present disclosure. Conversely, the features and functions of one module or unit described above may be further divided into a plurality of modules or units to be embodied.
Furthermore, although the steps of the methods in the present disclosure are depicted in a particular order in the drawings, this does not require or imply that the steps must be performed in that particular order or that all illustrated steps be performed in order to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps combined into one step to perform, and/or one step decomposed into multiple steps to perform, etc.
In an exemplary embodiment of the present disclosure, an electronic device capable of implementing the above method is also provided.
Those skilled in the art will appreciate that the various aspects of the present disclosure may be implemented as a system, method, or program product. Accordingly, various aspects of the disclosure may be embodied in the following forms, namely: an entirely hardware embodiment, an entirely software embodiment (including firmware, micro-code, etc.) or an embodiment combining hardware and software aspects may be referred to herein as a "circuit," module "or" system.
An electronic device 800 according to such an embodiment of the present disclosure is described below with reference to fig. 8. The electronic device 800 shown in fig. 8 is merely an example and should not be construed to limit the functionality and scope of use of embodiments of the present disclosure in any way.
As shown in fig. 8, the electronic device 800 is embodied in the form of a general purpose computing device. Components of electronic device 800 may include, but are not limited to: the at least one processing unit 810, the at least one storage unit 820, a bus 830 connecting the different system components (including the storage unit 820 and the processing unit 810), and a display unit 840.
Wherein the storage unit stores program code that is executable by the processing unit 810 such that the processing unit 810 performs steps according to various exemplary embodiments of the present disclosure described in the above section of the present specification. For example, the processing unit 810 may perform step S110 as shown in fig. 1: responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function; step S120: generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed; step S130: feeding back the result delay report mark to a task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay report mark; step S140: executing the task to be executed to obtain a task execution result, and feeding back the task execution result to the task scheduling center to realize asynchronous uploading of the task execution result.
The storage unit 820 may include readable media in the form of volatile storage units, such as Random Access Memory (RAM) 8201 and/or cache memory 8202, and may further include Read Only Memory (ROM) 8203.
Storage unit 820 may also include a program/utility 8204 having a set (at least one) of program modules 8205, such program modules 8205 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, each or some combination of which may include an implementation of a network environment.
Bus 830 may be one or more of several types of bus structures including a memory unit bus or memory unit controller, a peripheral bus, an accelerated graphics port, a processing unit, or a local bus using any of a variety of bus architectures.
The electronic device 800 may also communicate with one or more external devices 900 (e.g., keyboard, pointing device, bluetooth device, etc.), one or more devices that enable a user to interact with the electronic device 800, and/or any device (e.g., router, modem, etc.) that enables the electronic device 800 to communicate with one or more other computing devices. Such communication may occur through an input/output (I/O) interface 850. Also, electronic device 800 may communicate with one or more networks such as a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the Internet, through network adapter 860. As shown, network adapter 860 communicates with other modules of electronic device 800 over bus 830. It should be appreciated that although not shown, other hardware and/or software modules may be used in connection with electronic device 800, including, but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, data backup storage systems, and the like.
From the above description of embodiments, those skilled in the art will readily appreciate that the example embodiments described herein may be implemented in software, or may be implemented in software in combination with the necessary hardware. Thus, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (may be a CD-ROM, a U-disk, a mobile hard disk, etc.) or on a network, including several instructions to cause a computing device (may be a personal computer, a server, a terminal device, or a network device, etc.) to perform the method according to the embodiments of the present disclosure.
In an exemplary embodiment of the present disclosure, a computer-readable storage medium having stored thereon a program product capable of implementing the method described above in the present specification is also provided. In some possible implementations, various aspects of the disclosure may also be implemented in the form of a program product comprising program code for causing a terminal device to carry out the steps according to the various exemplary embodiments of the disclosure as described in the "exemplary methods" section of this specification, when the program product is run on the terminal device.
A program product for implementing the above-described method according to an embodiment of the present disclosure may employ a portable compact disc read-only memory (CD-ROM) and include program code, and may be run on a terminal device, such as a personal computer. However, the program product of the present disclosure is not limited thereto, and in this document, a readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium can be, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium would include the following: an electrical connection having one or more wires, a portable disk, a hard disk, random Access Memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
The computer readable signal medium may include a data signal propagated in baseband or as part of a carrier wave with readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A readable signal medium may also be any readable medium that is not a readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
Program code embodied on a readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Program code for carrying out operations of the present disclosure may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, C++ or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device, partly on a remote computing device, or entirely on the remote computing device or server. In the case of remote computing devices, the remote computing device may be connected to the user computing device through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computing device (e.g., connected via the Internet using an Internet service provider).
Furthermore, the above-described figures are only schematic illustrations of processes included in the method according to the exemplary embodiments of the present disclosure, and are not intended to be limiting. It will be readily appreciated that the processes shown in the above figures do not indicate or limit the temporal order of these processes. In addition, it is also readily understood that these processes may be performed synchronously or asynchronously, for example, among a plurality of modules.
Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any adaptations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.
Claims (10)
1. The method for reporting the task execution result is characterized by being configured in a task executor in a distributed task scheduling platform, and comprises the following steps of:
responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function;
Generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed;
feeding back the result delay report mark to a task scheduling center, so that the task scheduling center marks the task to be executed based on the result delay report mark;
executing the task to be executed to obtain a task execution result, and feeding back the task execution result to the task scheduling center to realize asynchronous uploading of the task execution result.
2. The method for reporting a task execution result according to claim 1, wherein the step of calling an execution result asynchronous reporting function in response to a task to be executed issued by a task scheduling center in a distributed task scheduling platform comprises:
responding to a task to be executed issued by a task scheduling center in a distributed task scheduling platform, and determining task execution time required by executing the task to be executed;
judging whether the task execution time is longer than the preset task result waiting time set by the task scheduling center;
and when the task execution time is determined to be longer than the preset task result waiting time, calling an execution result asynchronous reporting function.
3. The method for reporting the execution result of a task according to claim 2, wherein calling the execution result asynchronous reporting function comprises:
calling a byte code editing class library in the task executor, and defining byte codes to be compiled corresponding to the execution result asynchronous reporting function based on the byte code editing class library;
loading a Java virtual machine, compiling the byte code to be compiled based on the Java virtual machine to obtain the execution result asynchronous reporting function, and integrating the execution result asynchronous reporting function into a function library of the task executor;
and calling the execution result asynchronous reporting function from the function library.
4. The method for reporting a task execution result according to claim 2, wherein determining a task execution time required for executing the task to be executed includes:
decomposing the task to be executed to obtain a subtask to be executed included in the task to be executed; wherein, the task to be executed at least comprises one subtask to be executed;
generating a task attribute label corresponding to the subtask to be executed according to the target computing power resource type and the target computing power demand capability required by the subtask to be executed;
Distributing a target task execution node for a subtask to be executed from current computing power nodes in the task executor based on the task attribute label, and acquiring the current computing power resource type and the current computing power supply capability of the target task execution node;
and determining task execution time required for executing the task to be executed according to the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity.
5. The method according to claim 4, wherein determining the task execution time required for executing the task to be executed according to the current computing power resource type, the current computing power supply capability, the target computing power resource type, and the target computing power demand capability includes:
inputting the current computing power resource type, the current computing power supply capacity, the target computing power resource type and the target computing power demand capacity into a preset time prediction model to obtain a time prediction result;
and determining task execution time required by executing the task to be executed according to the time prediction result.
6. The method for reporting a task execution result according to claim 1, wherein executing the task to be executed to obtain a task execution result includes:
Issuing a subtask to be executed in the subtask to be executed to a target task execution node corresponding to the subtask to be executed, and executing the subtask to be executed through the target task execution node to obtain a task execution result.
7. The method for reporting a task execution result according to claim 6, wherein executing the subtasks to be executed to obtain a task execution result includes:
acquiring task execution codes corresponding to the subtasks to be executed, and determining a container generation script required by executing the task execution codes according to the current code category of the task execution codes;
executing the container generation script to obtain a container task mirror image corresponding to the task execution code, and submitting the container task mirror image to a container orchestration engine;
and calling a task execution tool required for scheduling and executing the container task mirror image according to the current task category of the subtask to be executed by the container orchestration engine, and executing the container task mirror image by the task execution tool to obtain the task execution result.
8. The utility model provides a report device of task execution result which characterized in that disposes the task executor in distributed task scheduling platform, report device of task execution result includes:
The function calling module is used for responding to a task to be executed issued by a task scheduling center in the distributed task scheduling platform, and calling an execution result asynchronous reporting function;
the result delay reporting mark generation module is used for generating a result delay reporting mark corresponding to the task to be executed according to the execution result asynchronous reporting function and the current task identifier of the task to be executed;
the result delay reporting mark feedback module is used for feeding back the result delay reporting mark to a task scheduling center so that the task scheduling center marks the task to be executed based on the result delay reporting mark;
and the task execution result feedback module is used for executing the task to be executed to obtain a task execution result and feeding the task execution result back to the task scheduling center so as to realize asynchronous uploading of the task execution result.
9. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements a method for reporting the results of a task execution according to any one of claims 1-7.
10. An electronic device, comprising:
A processor; and
a memory for storing executable instructions of the processor;
wherein the processor is configured to perform the method of reporting the results of task execution of any one of claims 1-7 via execution of the executable instructions.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311403081.5A CN117407139A (en) | 2023-10-26 | 2023-10-26 | Method and device for reporting task execution result, storage medium and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311403081.5A CN117407139A (en) | 2023-10-26 | 2023-10-26 | Method and device for reporting task execution result, storage medium and electronic equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117407139A true CN117407139A (en) | 2024-01-16 |
Family
ID=89486720
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311403081.5A Pending CN117407139A (en) | 2023-10-26 | 2023-10-26 | Method and device for reporting task execution result, storage medium and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117407139A (en) |
-
2023
- 2023-10-26 CN CN202311403081.5A patent/CN117407139A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107729139B (en) | Method and device for concurrently acquiring resources | |
| CN107016480B (en) | Task scheduling method, device and system | |
| CN109117252B (en) | Method and system for task processing based on container and container cluster management system | |
| CN111399897A (en) | Application issuing method and system based on kubernets | |
| CN111581948A (en) | Document analysis method, device, equipment and storage medium | |
| CN111324474B (en) | Celery task management method, system, equipment and storage medium | |
| CN112395736B (en) | Parallel simulation job scheduling method of distributed interactive simulation system | |
| US20220179711A1 (en) | Method For Platform-Based Scheduling Of Job Flow | |
| CN110609755A (en) | Message processing method, device, equipment and medium for cross-block chain node | |
| CN111694620B (en) | Interaction method, device and equipment of third party service and computer storage medium | |
| CN114205230A (en) | Method, system, medium and electronic device for configuring cloud native network element | |
| CN113986402A (en) | Function calling method and device, electronic equipment and storage medium | |
| CN113157411A (en) | Reliable configurable task system and device based on Celery | |
| CN110390450B (en) | Storage scheduling method and device, storage medium and electronic equipment | |
| CN115729679A (en) | Task processing method and device, computer readable storage medium and electronic device | |
| CN117407139A (en) | Method and device for reporting task execution result, storage medium and electronic equipment | |
| CN114816672A (en) | Virtual machine creation method and device, electronic equipment and storage medium | |
| CN115220908A (en) | Resource scheduling method, device, electronic equipment and storage medium | |
| CN113504916A (en) | Code updating method and device, computer equipment and medium | |
| CN108874625B (en) | Information processing method and device, electronic equipment and storage medium | |
| CN113204425A (en) | Method and device for process management internal thread, electronic equipment and storage medium | |
| CN113010280A (en) | Distributed task processing method, system, device, equipment and medium | |
| CN115552369A (en) | Compiling method, compiling device, compiling system, storage medium and electronic device | |
| CN112749193A (en) | Workflow processing method and device, storage medium and electronic equipment | |
| CN113407331A (en) | Task processing method and device and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |