TW201828053A - Code submission method and device that conducts inspection on a code to be submitted before the code in finally submitted - Google Patents

Abstract

The application proposes a code submission method and device. The method comprises: acquiring an increment code to be submitted that is to be submitted to a code warehouse; inspecting the increment code to be submitted; submitting the increment code to be submitted that has passed the inspection to the code warehouse, wherein by conducting inspection of the code before the submission of the code, the accuracy of the code can be ensured, allowing for problems to be identified as early as possible, without affecting other programs or procedures that need to use the submitted code.

Description

 Code submission method and device  

The embodiments of the present application relate to the field of communications technologies, and in particular, to a code submission method and device.

In the prior art, the tool monitors the change of the specified code warehouse, and when the new code is found to be put into the library, the new code of the code warehouse is checked out to the local, and the continuous integration execution is triggered according to the configuration item and the configuration step, but the trigger continues. An important prerequisite for integrated execution is that the code must be submitted to the code repository in real time, otherwise the execution of the task will not be triggered. The code submitted to the repository, if the continuous integration task fails due to a build break or test execution failure, has already had a substantial impact on the final test results and check out the code to other local team members, others must or rely on the task After the failure is fixed, it can continue to execute normally. This method is not conducive to early detection of problems and software engineering principles that violate the cost of the process. In addition, this method does not link the code review (CR: Code Review). It is included in the entire process, so the accuracy of the submitted code cannot be guaranteed.

In view of the defects in the prior art that are not conducive to early detection of the problem, and the accuracy of the code cannot be guaranteed, the present application proposes a code submission method, including: obtaining an incremental code to be submitted to be submitted to the code warehouse; The incremental code is detected; the incremental code to be submitted passed through the detection is submitted to the code repository.

Optionally, the detecting the incremental code to be submitted includes: performing code review on the incremental code to be submitted; performing task testing on the incremental code to be submitted.

If the code review passes and the task test passes, it is determined that the detection of the pending incremental code is passed.

Optionally, the performing the code review on the incremental code to be submitted includes: sending the incremental code to be submitted to multiple reviewers for review; receiving the review result of the reviewer's feedback; If the reviewer who exceeds the preset number reviews the incremental code to be submitted, it is determined that the incremental code review to be submitted is passed.

Optionally, the performing task testing on the incremental code to be submitted specifically includes: performing compilation on the dependent code of the incremental code to be submitted; performing task testing of the specified task when performing compilation on the dependent code; The task test of the preset task after the completion of the dependency code is completed; the task test result of the specified task and the preset task is obtained; if the task test result is all passed, it is determined that the task test of the incremental code to be submitted is passed.

Optionally, the compiling the dependent code of the incremental code to be submitted comprises: monitoring whether the dependent code of the incremental code to be submitted changes; compiling the dependent code that has changed; and extracting does not change. The program code corresponding to the dependent code is to a specified location, so as to directly reference the program library file when compiling the incremental code to be submitted.

Optionally, performing the task test, specifically: searching for a task profile in a specified location in the configuration library based on the storage path address of the incremental code to be submitted; if the task profile is not found in the specified location, The location of the parent directory of the specified location is searched for the task profile, and the task profile is searched by using the found task profile; if the task profile is found at the location of the parent path, the latest task profile found is extracted. And using the extracted latest task profile for task testing; if the task profile is not found at the location of the parent path, the task test is performed based on the preset common configuration.

Optionally, the submitting the detected incremental code to be submitted to the code warehouse after the detection comprises: determining whether there is a plurality of incremental codes to be submitted after the detection is passed; and if the determination result is yes, determining whether there is detection The plurality of to-be-delivered incremental codes after the corresponding ones correspond to the same original code, and the positions corresponding to the plurality of pending incremental codes after the detection of the same original code are identical; if the judgment result is yes, Determining the same incremental code that corresponds to the same original code and the position of the code modification is the incremental code to be submitted after the detection is passed, and the incremental code to be submitted after the detection is passed; And performing the priority order evaluation after the passing of the incremental code to be submitted; and submitting the incremental code to be submitted to the code warehouse after the conflict is detected in order from the highest priority to the priority order.

Optionally, the priority evaluation factor includes a modification time of modifying the code, a code modification line number, and a code importance; the priority evaluation factor is based on the plurality of conflicting and the detected pending submission increments The code performs the priority evaluation, which includes: evaluating the importance of the code of each of the conflicting and detected passing incremental codes based on the degree of influence, and obtaining the modification time of each of the conflicting and detected passing incremental codes to be submitted. The code modifies the number of rows; based on the modification time, the code modifies the number of rows, and the code importance to evaluate the priority order of each of the conflicting and detected through-delivery incremental codes; determining, based on the evaluation result, each of the conflicts and the detected pass-to-submit The priority order of the incremental code.

The application also provides a code submission device, comprising: an acquisition module, configured to acquire an incremental code to be submitted to be submitted to the code warehouse; a detection module, configured to detect the incremental code to be submitted; The module is configured to submit the detected incremental code to be submitted to the code warehouse.

Optionally, the detecting module is specifically configured to: perform code review on the incremental code to be submitted; and perform task testing on the incremental code to be submitted.

If the code review passes and the task test passes, it is determined that the detection of the pending incremental code is passed.

Optionally, the detecting module performs code review on the incremental code to be submitted, and specifically includes: sending the incremental code to be submitted to multiple reviewers for review; and receiving the review result of the reviewer's feedback; The result of the review is that the reviewer who exceeds the preset number reviews the pending incremental code to pass, and then determines that the incremental code review to be submitted is passed.

Optionally, the detecting module performs task testing on the incremental code to be submitted, and specifically includes: performing compiling on the dependent code of the incremental code to be submitted; performing a task of specifying a task when compiling the dependent code Testing; performing a task test of a preset task after compiling the dependent code; obtaining a task test result of the specified task and the preset task; and if the task test result is all passed, determining a task test for the incremental code to be submitted by.

Optionally, the detecting module performs compilation on the dependent code of the incremental code to be submitted, and specifically includes: monitoring whether the dependent code of the incremental code to be submitted changes; compiling a dependent code that has changed; extracting The library file corresponding to the dependent code that has not changed to the specified location, so as to directly reference the program library file when compiling the incremental code to be submitted.

Optionally, the detecting module performs task testing, specifically: searching for a task profile in a specified location in the configuration library based on the storage path address of the incremental code to be submitted; if the task setting is not found in the specified location The file is searched for the task profile at the location of the parent directory of the specified location, and the task profile is searched by using the found task profile; if the task profile is found at the location of the parent path, the found profile is extracted. The latest task profile, and the task test is performed by using the extracted latest task profile; if the task profile is not found at the location of the parent path, the task test is performed based on the preset common configuration.

Optionally, the submitting module is specifically configured to: determine whether there is a plurality of incremental codes to be submitted after the detection is passed; if the determination result is yes, determine whether there is a plurality of incremental codes to be submitted after the detection is passed. In the same original code, and corresponding to the same original code, the position of the code to be submitted after the detection of the incremental code to be submitted is consistent; if the judgment result is yes, it is determined that the same original code is corresponding, and the code is modified. The incremental code of the position to be submitted after the multiple detections are consistent with the incremental code to be submitted after the conflict is detected; and the incremental code to be submitted after the conflict is detected and the detection is passed based on the priority evaluation factor Priority evaluation; submit the incremental code to be submitted to the code warehouse in order of priority according to the priority order of the evaluation.

Optionally, the priority evaluation factor includes a modification time of modifying the code, a code modification line number, and a code importance; and the submitting module is based on the priority evaluation factor to the plurality of conflicts and the detection after the passage The incremental code is submitted for priority evaluation, which includes: evaluating the importance of the code of each of the conflicting and detected passing incremental codes based on the degree of influence, and obtaining the incremental code to be submitted that each conflict exists and passes the test. Modifying the time and code to modify the number of rows; based on the modification time, the number of lines modified by the code, and the importance of the code to evaluate the priority order of each conflicting and detected incremental code to be submitted; determining each conflict based on the evaluation result and passing the detection The priority order of the incremental code to be submitted.

Compared with the prior art, in the present application, the incremental code to be submitted submitted to the code warehouse is obtained by acquiring the incremental code to be submitted; and the incremental code to be submitted through the detection is submitted to the code warehouse. Therefore, the code is detected before the code is submitted, the accuracy of the submitted code is ensured, and the problem can be found as early as possible, without affecting other programs or processes that need to use the submitted code.

201‧‧‧Getting module

202‧‧‧Test module

203‧‧‧Submit module

1 is a schematic flowchart of a code submission method proposed in the present application; FIG. 2 is a schematic diagram of a result of a code submission device proposed in the present application.

As in the prior art, the risk assessment solution in the prior art cannot accurately assess the risk. To this end, in order to better assess the risk, a code submission method is proposed in the present application. As shown in FIG. 1, the method includes the following steps: Step 101: Get the incremental code to be submitted that is ready to be submitted to the code repository.

In a specific application scenario, after the user has modified the code, the user is ready to submit the code to the code repository, and thus the modified incremental code to be submitted to the code warehouse is obtained, which is different from this. Other code will not perform the acquired operation.

In step 102, the incremental code is submitted for detection.

After obtaining the incremental code to be submitted, it is necessary to detect the submitted incremental code, and the specific detection includes: performing the code review for submitting the incremental code and performing the task test for submitting the incremental code, that is, including the following two Process:

(1), to submit the incremental code for code review:

Sending the incremental code to be submitted to multiple reviewers for review; receiving the review result of the reviewer's feedback; if the review result is more than a preset number of reviewers reviewing the pending incremental code pass, then determining the incremental code to be submitted The review was passed.

Specifically, the incremental code to be submitted is sent to the reviewer, and after the reviewer reviews the incremental code to be submitted, the review result is given, passed or not, and in order to ensure the accuracy of the review, the preset may only be exceeded. The preset number of reviewers pass the review, for example, it can be set to 2 reviewers to pass the review, and then the incremental code to be submitted can be determined to pass.

(2), to submit the incremental code for task testing, specifically:

Compute compilation of dependent code that submits incremental code; perform task test of specified task when compiling with dependent code; perform task test of preset task after compiling dependent code; obtain task test of specified task and preset task Result; if the task test result is all passed, it is determined that the task test for submitting the incremental code passes.

Some test tasks require task testing when compiling, such as UT (Unit Test), and some need to perform task testing after compilation is completed, such as BVT (Build Verification Test). The characteristics of the test task to select the appropriate timing for task testing, no longer elaborate here, and the task test passes the results of all the required task tests.

Compiling the dependent code that submits the incremental code, including: monitoring whether the dependent code of the incremental code to be submitted changes; compiling the dependent code that has changed; extracting the library file corresponding to the dependent code that has not changed to the specified location In order to directly reference the library file when compiling the incremental code to be submitted.

The specific compilation does not need to be fully compiled. Since the incremental code to be submitted will refer to some code to implement the corresponding function, the referenced code is the dependent code of the incremental code to be submitted, and thus, when compiling It only needs to compile the dependent code that has changed. For the dependent code that has not changed, you can directly extract the library file of the dependent code to the specified location without executing the compilation process, thus ensuring the implementation of the function. At the same time, it reduces resource consumption and improves efficiency.

Specifically, the task test includes: searching for a task profile in a specified location in the configuration repository based on a storage path address to be submitted with an incremental code (a subsequent process of submitting the incremental code according to the storage path address); If the task profile is not found in the specified location, the task profile is found in the location of the parent directory of the specified location, and the task profile is searched by using the found task profile; if the task profile is found in the location of the parent path, the search is performed. Go to the latest task profile and use the extracted latest task profile for task testing; if the task profile is not found at the location of the parent path, the task is tested based on the preset common configuration.

Specifically, since the task test needs to be performed according to the task profile, and the test task may have been performed before, there is a task profile, and in this case, the task profile can be used to perform the task test, and if Before the task test, the task profile will exist in the specified location (can be found based on the storage path address of the incremental code to be submitted), or the location of the parent directory of the specified location, so first look in the specified location, if found , according to the task profile for task testing; if not found, the location of the parent directory, that is, the location of the upper layer of the specified location, if found, based on the latest task profile found Perform task testing; if you have not performed a task test before, there is no task configuration file. In this case, you can perform task testing based on the common configuration.

In this way, by submitting the incremental code to submit the incremental code for code review and task testing, when the code review passes and the task test passes, it is determined that the detection of the submitted incremental code is passed.

Specifically, after the step 102 is used to detect the submitted incremental code, there are two results, and the detection passes or fails. If the detection passes, step 103 is performed, and if the detection fails, the operation ends and/or the detection is not performed. Pass the alarm.

Step 103: Submit the incremental code to be submitted for detection.

Since only the incremental code to be submitted for detection is submitted to the code warehouse, the specific submission process includes: determining whether there are multiple incremental codes to be submitted after the detection is passed; if the determination result is yes, determining whether there is detection The plurality of to-be-delivered incremental codes after the corresponding ones correspond to the same original code, and the positions corresponding to the plurality of pending incremental codes after the detection of the same original code are identical; if the judgment result is yes, Determining the same incremental code that corresponds to the same original code and the position of the code modification is the incremental code to be submitted after the detection is passed, and the incremental code to be submitted after the detection is passed; And performing the priority order evaluation after the passing of the incremental code to be submitted; and submitting the incremental code to be submitted to the code warehouse after the conflict is detected in order from the highest priority to the priority order.

Specifically, since the same original code may be modified by multiple modifiers at the same time, and the modified positions are consistent (specifically, the number of modified lines of code, for example, the modification is the 7th line), this will generate multiple pending submissions. A quantity code, and a plurality of to-be-delivered incremental codes correspond to the same original code. In this case, since there is a conflict between the plurality of pending incremental codes, in this case, multiple to-be-committed The incremental code performs priority evaluation to determine the priority level, and finally determines the order of submission based on the priority level. In a specific embodiment, the evaluation factor of the priority order may include the modification time of modifying the code. The code modifies the number of lines and the importance of the code; specifically, if the other two factors are consistent, the earlier the modification time, the higher the priority order; the higher the code importance (that is, the greater the impact of the modified code) The higher the priority order is; the more the number of lines modified by the code, the higher the priority order; in this case, the factor is evaluated based on the priority order. The priority code to be submitted for conflicting and detecting the pending incremental code includes: evaluating the importance of the code of each of the conflicting and detected passing incremental codes based on the degree of influence, and obtaining each conflict and detecting The modification time of the incremental code to be submitted and the number of code modification lines; based on the modification time, the number of lines modified by the code, and the importance of the code to evaluate the priority order of each conflicting and detected incremental code to be submitted; based on the evaluation As a result, the priority order of each incremental code to be submitted that is conflicting and detected is determined; specifically, a formula ΣP=(C, K, T) can be used for evaluation. Specifically, C is the code modification line number, K is The importance of the code (specifically the degree of influence of the modified code), T is the time factor, the initial reference value is 1, sorted in reverse order of the submission time, and the value of T is incremented by 2 ^(n-1) . These three factors are used to evaluate the priority order ΣP of a plurality of conflicting and detected incremental codes to be submitted.

In order to further explain the present application, the second embodiment of the present application also discloses a code submission in a specific scenario, including the following steps; Step 1, the Review Board (ie, the review board, which is part of the entire server) acquires the user. After the code is modified, the modified code uploaded by the RBT Client (RBT client), specifically, the modified code requests a review request for reviewing the modified code, and the Review Board assigns a review ID to the request (Review ID) ), and return the Review ID to the RBT Client, so that the RBT Client sends the Review ID and other modified code identifiers to the Task Server (task server).

Step 2: The Review Board sends the modified code to multiple reviewers for review, and obtains the review result of the reviewer (the review pass or the review fails), and the Task Server polls the Review Board based on the Review ID to obtain the review result. If the result of the review is that two or more examiners have passed the review, it can be determined that the code review is passed.

In the specific process, after the reviewer has completed the review, the reviewer will give the mark of the review. One reviewer can give a valid +1 ship it mark, and can set the mark with the requirement of +2 to pass the review. This is done by querying ship it to determine if the review is passed.

Step 3: The Task Server obtains the configuration file required for the test task, and sends the configuration file to the CISE (Continuous Integration Servevice Engine), so that the CISE performs the task test based on the configuration file, and returns the test result to the test result. Task Server, Task Server is stored in the database after receiving the test results.

The Task Server restores the modified code based on the code identifier, such as the difference file, the original code identifier, the version server, etc., of course, the modified code can also be obtained directly, but considering that the original code may be long, in a recovery manner High efficiency, saving resources, after assigning the modified code, find the task-related configuration file (Yaml configuration file), which specifically includes the following three situations: First, from the SVN/Git script library, Detect whether there is a Yaml profile in the specified location. If it exists, execute the entire task according to the profile. Second, if there is no Yaml profile in the specified location, first according to the SVN/Git address, according to the parent path of the specified location (ie only to the trunk or The branch directory structure is searched in the configuration library maintained by the Task Server. If there is a configuration corresponding to the parent directory, the latest rule configuration in the parent directory is automatically obtained as the configuration of the newly added task. 3. For any non-existent configuration The configured task obtains the general task configuration rule from the database and processes it according to the preset execution rule. The preset configuration rule is to distinguish the language environment, and the specific language environment is obtained according to the information transmitted by the RBT client; specifically, the task also includes compiling, and specifically, when preparing for compiling, first obtaining the dependent code for determining the modified code. The change can be determined based on the change time stamp to see if it is consistent. If it is consistent, it indicates that no change has occurred. Based on the makefile (where the relationship between the modified code identifier and the dependent code is stored), the latest makefile is generated. Configure the copy, replace the previous operation that relies on compiling and generating the dependent library with the library file of the specified path. At the same time, dynamically update the Yaml configuration file (using the configuration copy of the makefile, the task sends a change), and download the program file to the specified path. , consistent with the makefile configuration copy; for the case of changes, keep the configuration items unchanged, execute the compilation and build process according to the dependency; after the execution of the CISE task, upload the latest compiled library file to OSS (Open Storage) Service) in the cloud space, according to the file name + Unix timestamp Put, while the compiled modules and timestamp information (i.e., identity) of the string will be as JSON interface updates to the repository by Save, as a basis for the subsequent execution of the task, data string part and JSON format is as follows:

Step 4: The Task Server polls the task test result in the database. If the review passes, the modified code can be submitted.

Of course, when the code needs to be submitted, in the process of pre-submission, the code review has been passed, and the task test is passed. If the original code corresponding to the modified code is found, other code changes occur synchronously (ie, Multiple code changes correspond to the same original code, and the location of the modification is consistent), and multiple code changes are also passed through the review and task test. For this scenario, the modification time of the code from the modification of the code is (T), change complexity (C) and critical path impact (K) comprehensive comparison of the three factors, wherein the complexity of the change is embodied in the code modification line number, the more code modification lines, the higher the complexity of the change; The critical path impact is reflected in the importance of the code. The vector modulus length is judged according to the formula: ΣP=(C, K, T), where: the change complexity C is determined by the number of lines modified by the code; the critical path influence is changed. The number of methods affected is used as the basis for judging. The more the number of methods to change the influence, the more corresponding, the higher the importance of the code; for the time factor T, Larger value jobs submitted its initial reference value is 1, among a plurality of tasks in the reverse order submission time, T values according to 2 ^(n-1) is incremented, so as to ensure forward the task priority is submitted; here to Two concurrent submissions of related files of the same module code are described as examples. The number of incremental code lines of the first submitted task is 20, the number of affected methods is 2, and the value of T is 2 (the reference value is 1, Reverse order); the number of incremental code lines for the second commit task is 20, the number of affected methods is 6, and the value of T is 1. The formula for calculating the modulus length of a vector is According to the calculation result, it can be determined that the code of the second submitting task is preferentially submitted.

The embodiment of the present application further discloses a code submission device, as shown in FIG. 2, comprising: an acquisition module 201, configured to acquire an incremental code to be submitted submitted to a code warehouse; and a detection module 202, configured to The submitting the incremental code for detecting; the submitting module 203 is configured to submit the incremental code to be submitted for detection to the code warehouse.

The detecting module 202 is specifically configured to: perform code review on the incremental code to be submitted; perform task testing on the incremental code to be submitted.

If the code review passes and the task test passes, it is determined that the detection of the pending incremental code is passed.

The detecting module 202 performs code review on the incremental code to be submitted, and specifically includes: sending the incremental code to be submitted to multiple reviewers for review; and receiving the review result of the reviewer's feedback; if the review result is If the reviewer who exceeds the preset number reviews the incremental code to be submitted, it is determined that the incremental code review to be submitted is passed.

The detecting module 202 performs task testing on the incremental code to be submitted, and specifically includes: performing compiling on the dependent code of the incremental code to be submitted; performing task testing of the specified task when compiling the dependent code; The task test of the preset task after the completion of the dependency code is completed; the task test result of the specified task and the preset task is obtained; if the task test result is all passed, it is determined that the task test of the incremental code to be submitted is passed.

The detecting module 202 performs compilation on the dependent code of the incremental code to be submitted, and specifically includes: monitoring whether the dependent code of the incremental code to be submitted changes; compiling the dependent code that has changed; and extracting does not change. The program code corresponding to the dependent code is to a specified location, so as to directly reference the program library file when compiling the incremental code to be submitted.

The detecting module 202 performs task testing, specifically: searching for a task profile in a specified location in the configuration library based on the storage path address of the incremental code to be submitted; if the task profile is not found in the specified location, Searching for the task profile in the location of the parent directory of the specified location, and using the found task profile to perform task testing; if the task profile is found in the location of the parent path, extracting the latest task found The profile is set and the task test is performed by using the extracted latest task profile; if the task profile is not found at the location of the parent path, the task test is performed based on the preset common configuration.

The submitting module 203 is specifically configured to: determine whether there is a plurality of incremental codes to be submitted after the detection is passed; if the determination result is yes, determine whether there are multiple pending incremental codes corresponding to the same original code after the detection is passed. And corresponding to the same original code, the position of the code to be submitted after the detection of the incremental code is consistent; if the judgment result is yes, it is determined that the same original code is corresponding, and the position of the code modification is consistent. After the detection, the incremental code to be submitted is the conflicting code and the incremental code to be submitted after the detection is passed; based on the priority evaluation factor, the priority code of the pending incremental code after the detection is passed; The priority order of the evaluation is sequentially submitted from high to low, and the incremental code to be submitted after the detection is passed to the code warehouse.

The priority evaluation factor includes a modification time for modifying the code, a code modification line number, and a code importance; the submission module 203 submits the module based on the priority evaluation factor to the plurality of conflicts and the detection after the passage The incremental code is submitted for priority evaluation, which includes: evaluating the importance of the code of each of the conflicting and detected passing incremental codes based on the degree of influence, and obtaining the incremental code to be submitted that each conflict exists and passes the test. Modifying the time and code to modify the number of rows; based on the modification time, the number of lines modified by the code, and the importance of the code to evaluate the priority order of each conflicting and detected incremental code to be submitted; determining each conflict based on the evaluation result and passing the detection The priority order of the incremental code to be submitted.

Compared with the prior art, in the present application, after the incremental code to be submitted is obtained, the incremental code to be submitted is detected, and only the incremental code to be submitted after the re-test is passed, so that the code is submitted, and then the guarantee is guaranteed. The accuracy of the submitted code, and the problem can be found as early as possible, without affecting other programs or processes that need to use the submitted code.

Through the description of the above embodiments, those skilled in the art can clearly understand that the present application can be implemented by hardware, or by means of a software plus a necessary universal hardware platform. Based on the understanding, the technical solution of the present application can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (which can be a CD-ROM, a USB flash drive, a mobile hard disk, etc.). A number of instructions are included to cause a computer device (which may be a personal computer, server, or network device, etc.) to perform the methods described in the various implementation scenarios of the present application.

A person skilled in the art can understand that the drawings are only a schematic diagram of a preferred implementation scenario, and the modules or processes in the drawings are not necessarily required to implement the present application.

A person skilled in the art may understand that the modules in the device in the implementation scenario may be distributed in the device that implements the scenario according to the implementation scenario description, or may be correspondingly changed in one or more devices different from the implementation scenario. The modules of the above implementation scenarios may be combined into one module, or may be further split into multiple sub-modules.

The serial numbers of the above application are for the purpose of description only and do not represent the advantages and disadvantages of the implementation scenario.

The above disclosure is only a few specific implementation scenarios of the present application, but the present application is not limited thereto, and any changes that can be made by those skilled in the art should fall within the protection scope of the present application.

Claims (16)

 A code submission method, comprising: obtaining an incremental code to be submitted submitted to the code warehouse; detecting the incremental code to be submitted; and submitting the incremental code to be submitted through the detection to the code warehouse.    The method of claim 1, wherein the detecting the incremental code to be submitted comprises: performing code review on the incremental code to be submitted; and adding the incremental code to be submitted. Performing a task test; if the code review passes and the task test passes, it is determined that the detection of the pending incremental code is passed.    The method of claim 2, wherein the performing the code review on the incremental code to be submitted comprises: sending the incremental code to be submitted to a plurality of reviewers for review; receiving the review If the review result is that the reviewer exceeds the preset number of reviewers, the incremental code review is to be submitted.    The method of claim 2, wherein the performing the task test on the incremental code to be submitted comprises: performing compilation on the dependent code of the incremental code to be submitted; performing on the dependent code Performing a task test of a specified task at compile time; performing a task test of a preset task after compiling the dependent code; obtaining a task test result of the specified task and the preset task; and if the task test result is all passed, determining the waiting for the task The task test that submitted the incremental code passed.    The method of claim 4, wherein the compiling the dependent code of the incremental code to be submitted comprises: monitoring whether the dependent code of the incremental code to be submitted changes; compiling occurs. The dependent dependency code is extracted; the library file corresponding to the dependent code that has not changed is extracted to a specified location, so that the program library file is directly referenced when compiling the incremental code to be submitted.    The method of claim 4, wherein the performing the task test comprises: searching for a task profile in a specified location in the configuration repository based on the storage path address of the incremental code to be submitted; if not searching at the specified location Go to the task profile, search for the task profile at the location of the parent directory of the specified location, and perform task test using the found task profile; if the task profile is found at the location of the parent path Extracting the latest task profile found, and using the extracted latest task profile for task testing; if the task profile is not found at the location of the parent path, the task is tested based on the preset common configuration.    The method of claim 1, wherein the submitting the detected incremental code to be submitted to the code warehouse after the detection comprises: determining whether there is a plurality of incremental codes to be submitted after the detection is passed; If the result of the determination is yes, it is determined whether there is a plurality of to-be-delivered incremental codes corresponding to the same original code after the detection is passed, and the code corresponding to the incremental code corresponding to the same original code is used for the code modification. If the result of the determination is YES, it is determined that the incremental code corresponding to the same original code and the position of the code modification is consistent with the pending code to be submitted, and the incremental code to be submitted after the detection is passed; Prioritizing the plurality of conflicting and post-tested incremental codes to be submitted based on the priority evaluation factor; submitting the conflicts to be submitted in descending order according to the priority order of the evaluations Code to the code repository.    The method of claim 7, wherein the priority evaluation factor includes a modification time of modifying the code, a code modification line number, and a code importance; the priority evaluation factor is based on the plurality of presence factors The priority of the conflict is detected by the incremental code to be submitted after the detection, and the method includes: estimating the importance of the code of each of the conflicting and detecting the pending incremental code based on the degree of influence, and obtaining each conflict and detecting the pass The modification time of the incremental code to be submitted and the number of code modification lines; based on the modification time, the number of lines modified by the code, and the code importance to evaluate the priority order of each conflicting and detected incremental code to be submitted; based on the evaluation result Determine the priority order of each pending incremental code that has conflicts and passes the test.    A code submission device, comprising: an acquisition module, configured to acquire an incremental code to be submitted to be submitted to a code warehouse; a detection module, configured to detect the incremental code to be submitted; and submit a module , used to submit the detected incremental code to be submitted to the code repository.    The device of claim 9, wherein the detecting module is configured to perform code review on the incremental code to be submitted, and perform task testing on the incremental code to be submitted. If the code review passes and the task test passes, it is determined that the detection of the pending incremental code is passed.    The device of claim 10, wherein the detecting module performs code review on the incremental code to be submitted, specifically: sending the incremental code to be submitted to multiple reviewers for review Receiving the review result of the reviewer's feedback; if the review result is that the reviewer who exceeds the preset number reviews the incremental code to be submitted, it is determined that the incremental code review to be submitted is passed.    The device of claim 10, wherein the detecting module performs task testing on the incremental code to be submitted, specifically: performing compilation on the dependent code of the incremental code to be submitted; Relying on the code to perform the task test of the specified task when compiling; performing the task test of the preset task after compiling the dependent code; obtaining the task test result of the specified task and the preset task; if the task test result is all passed, determining the pair The task of the incremental code to be submitted is tested.    The device of claim 12, wherein the detecting module performs compilation on the dependent code of the incremental code to be submitted, and specifically includes: monitoring whether the dependent code of the incremental code to be submitted changes. Compiling the dependent code that has changed; extracting the library file corresponding to the dependent code that has not changed to the specified location, so as to directly reference the program library file when compiling the incremental code to be submitted.    The device of claim 12, wherein the detecting module performs task testing, specifically: searching for a task profile in a specified location in the configuration library based on the storage path address of the incremental code to be submitted; If the task profile is not found in the specified location, the task profile is searched for in the location of the parent directory of the specified location, and the task profile is searched by using the found task profile; if the parent path is found in the location of the parent path The task profile, extracting the found latest task profile, and performing task test using the extracted latest task profile; if the task profile is not found at the location of the parent path, based on the preset common configuration To perform task testing.    The device of claim 9, wherein the submitting module is specifically configured to: determine whether there is a plurality of incremental codes to be submitted after the detection is passed; if the determination result is yes, determine whether the detection passes The plurality of pending incremental codes corresponding to the same original code, and corresponding to the same original code, after the detection of the plurality of to-be-delivered incremental codes, the code modification is consistent; if the determination result is yes, then determining Corresponding to the same original code, and the position of the code modification is consistent, the incremental code to be submitted is the conflicting code and the incremental code to be submitted after the detection is passed; The priority code to be submitted is detected after the passing of the incremental code to be submitted; and the incremental code to be submitted after the conflict is detected and sequentially passed to the code warehouse according to the priority order of the evaluation.    The device of claim 15, wherein the priority evaluation factor comprises a modification time of modifying the code, a code modification line number, and a code importance; the submitting module is based on a priority evaluation factor pair A plurality of conflicting and detected incremental code to be submitted for priority evaluation, including: evaluating the importance of the code of each of the conflicting and detected passing incremental codes based on the degree of influence, and obtaining each conflict And detecting the modified time of the pending incremental code and the number of modified lines of the code; based on the modification time, the number of modified lines of the code and the importance of the code to evaluate the priority order of each of the conflicting and detected incremental codes to be submitted; Based on the evaluation result, the priority order of each of the conflicting and detected passing incremental codes is determined.