A method and apparatus for monitoring uncommitted code

Abstract

The embodiment of the application provides a kind of un-delivered code monitoring method and device, it can be used in artificial intelligence technical field, the method comprises: the matching of the delivery information table and the submission information table obtained, generates un-delivered code list;According to development mode, the modifier of delivery code is matched;According to the generated hierarchical code list, un-delivered code list and the modifier of delivery code, generate monitoring list, can accurately monitor to un-delivered code, improve the accuracy and efficiency of monitoring.

Description

Technical Field

[0001] This invention relates to the field of computer technology, particularly to the field of artificial intelligence technology, and especially to a method and apparatus for monitoring undelivered code. Background Technology

[0002] With the increasing adoption of open platforms across various applications, more and more application development is utilizing open platform technologies to complete and deliver versions. Compared to the mature version checking mechanisms of mainframe applications, platform version checking technologies are relatively weak. Among related technologies, checking for undelivered code primarily involves checking for incremental code within the version package or determining whether new code needs to be delivered based on the latest baseline name. However, relying solely on the latest baseline name and whether the code has been packaged in the continuous delivery pipeline does not necessarily indicate actual delivery, leading to low accuracy. Furthermore, checking version packages individually requires verifying for incremental code, which is inefficient. Summary of the Invention

[0003] One object of the present invention is to provide a method for monitoring undelivered code, which can accurately monitor undelivered code and improve the accuracy and efficiency of monitoring. Another object of the present invention is to provide an apparatus for monitoring undelivered code. A further object of the present invention is to provide a computer-readable medium. A still other object of the present invention is to provide a computer device.

[0004] To achieve the above objectives, this invention discloses a method for monitoring undelivered code, comprising:

[0005] The obtained delivery information table and submission information table are matched to generate a list of undelivered code;

[0006] Based on the development model, identify the person who modified the delivered code;

[0007] A monitoring list is generated based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered code.

[0008] Preferably, the delivery information sheet includes the product number, version delivery information, and destination baseline;

[0009] The obtained delivery information table and commit information table are matched to generate a list of undelivered code, including:

[0010] The final delivery version is determined based on the delivery information sheet;

[0011] The final delivery version's target baseline is matched with the commit message table to generate a list of undelivered code.

[0012] Preferably, the final delivery version is determined based on the delivery information sheet, including:

[0013] Retrieve multiple product numbers with the same version of delivery information from the delivery information table;

[0014] The version delivery information corresponding to the largest product number is taken as the final delivery version.

[0015] Preferably, the commit information form includes the application, repository, branch, and code commit time;

[0016] Match the target baseline of the final delivery version with the commit message form to generate a list of undelivered code, including:

[0017] The target baseline is parsed to generate baseline information, which includes the application, repository, branch, and packaging time.

[0018] The application, repository, and branch in the commit information table are matched with the application, repository, and branch in the baseline information to find the packaging time and code commit time corresponding to the same application, repository, and branch.

[0019] Compare the packaging time and code submission time, and identify information where the code submission time is later than the packaging time as undelivered information;

[0020] Generate a list of undelivered codes based on the undelivered information.

[0021] Preferably, the development model is a monthly development model;

[0022] Based on the development model, identify the modifiers who delivered the code, including:

[0023] Based on the list of undelivered code, retrieve the corresponding modifier from the commit information table.

[0024] Preferably, the development mode is the feature development mode, the branch in the commit information table is the feature branch, and the branch in the delivery information table is the release branch;

[0025] Based on the development model, identify the modifiers who delivered the code, including:

[0026] Get the parent node of the node in the undelivered code list on the release branch that corresponds to at least one candidate modifier. The parent node is located on the feature branch, and each candidate modifier has a code commit time.

[0027] Compare the commit time of each code with the packaging time of the node, and filter out at least one candidate modifier whose code commit time is less than the packaging time;

[0028] Select the maximum value from the code commit times of at least one candidate modifier, and determine the candidate modifier corresponding to the maximum value as the modifier who delivered the code.

[0029] Preferably, before generating the monitoring list based on the generated hierarchical code list, undelivered code list, and the modifiers of delivered code, the process also includes:

[0030] Retrieve the repositories from the undelivered code list;

[0031] Determine if the specified test directory exists in the repository;

[0032] If so, store the code in the specified test directory as the test code listing, and store the code in directories other than the specified test directory as the production code listing;

[0033] Generate a tiered code list based on the test code list and the production code list.

[0034] Preferably, after generating the monitoring list based on the generated hierarchical code list, undelivered code list, and the modifiers of delivered code, the following is also included:

[0035] Warnings are issued to the monitoring list by specifying the warning method.

[0036] The present invention also discloses an undelivered code monitoring device, comprising:

[0037] The first matching unit is used to match the obtained delivery information table and submission information table to generate a list of undelivered code;

[0038] The second matching unit is used to match the person who modified the delivered code based on the development mode;

[0039] The generation unit is used to generate a monitoring list based on the generated hierarchical code list, undelivered code list, and the modifiers of delivered code.

[0040] The present invention also discloses a computer-readable medium having a computer program stored thereon, which, when executed by a processor, implements the method described above.

[0041] The present invention also discloses a computer device, including a memory and a processor, wherein the memory is used to store information including program instructions, and the processor is used to control the execution of the program instructions, wherein the processor executes the program to implement the method described above.

[0042] This invention matches the acquired delivery information table and submission information table to generate a list of undelivered code; it matches the modifiers of delivered code according to the development mode; and it generates a monitoring list based on the generated hierarchical code list, the list of undelivered code, and the modifiers of delivered code, which can accurately monitor undelivered code and improve the accuracy and efficiency of monitoring. Attached Figure Description

[0043] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0044] Figure 1 A flowchart illustrating an undelivered code monitoring method provided in an embodiment of the present invention;

[0045] Figure 2 A flowchart illustrating yet another method for monitoring undelivered code provided in an embodiment of the present invention;

[0046] Figure 3 A logical diagram illustrating an accurate acquisition of a list of undelivered codes, provided as an embodiment of the present invention;

[0047] Figure 4 A schematic diagram illustrating a code modification scenario provided by an embodiment of the present invention;

[0048] Figure 5 This is a schematic diagram illustrating yet another code modification scenario provided by an embodiment of the present invention;

[0049] Figure 6 This is a schematic diagram illustrating yet another code modification scenario provided by an embodiment of the present invention;

[0050] Figure 7 This is a schematic diagram of the structure of an undelivered code monitoring device provided in an embodiment of the present invention;

[0051] Figure 8 This is a schematic diagram of the structure of a computer device provided in an embodiment of the present invention. Detailed Implementation

[0052] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0053] It should be noted that the non-deliverable code monitoring method and apparatus disclosed in this application can be used in the field of artificial intelligence technology, or in any field other than artificial intelligence technology. The application field of the non-deliverable code monitoring method and apparatus disclosed in this application is not limited.

[0054] To facilitate understanding of the technical solution provided in this application, the relevant content of the technical solution will be explained below. Currently, the accuracy and efficiency of obtaining the undelivered code list and corresponding modifiers from the version package dimension or baseline dimension in production inspection are low. This invention provides a method for directly obtaining the undelivered code list from the code level. Each code version is delivered on a continuous delivery pipeline, which is an automated version continuous delivery system that displays the status of the entire process from source code management to production, provides visualization functions, and can quickly realize business value. The delivered version is obtained at the version granularity of version plan, application and service group. The service group is an architectural unit composed of a group of services and physical data objects (table groups) of an application within a physical application, based on the needs of differentiated R&D management, the difference in the importance of business services, and the end-to-end R&D of business modules. The service group is used to support R&D management work such as R&D division of labor, code management, version creation, production deployment and operation, making it more refined. This application provides a method for monitoring undelivered code in an environment where monthly development mode and feature development mode coexist. In the monthly development mode, one or more branches are created for each monthly version based on the project's production release schedule. Patches for monthly versions can be merged and synchronized to the next monthly version through the corresponding branches. The monthly development mode is the first-level mode within the feature development mode. The feature development mode, based on industry-standard feature development modes, has four levels. Feature level 1 is the monthly development mode, which is parallel development; feature level 4 is the serial development mode; and features levels 2 and 3 are transitional development modes between parallel and serial development.

[0055] The following uses an undelivered code monitoring device as an example to illustrate the implementation process of the undelivered code monitoring method provided in this embodiment of the invention. It is understood that the execution subject of the undelivered code monitoring method provided in this embodiment of the invention includes, but is not limited to, an undelivered code monitoring device.

[0056] Figure 1 A flowchart of an undelivered code monitoring method provided in an embodiment of the present invention is shown below. Figure 1 As shown, the method includes:

[0057] Step 101: Match the obtained delivery information table and submission information table to generate a list of undelivered code.

[0058] Step 102: Based on the development model, identify the person who modified the delivered code.

[0059] Step 103: Generate a monitoring list based on the generated hierarchical code list, undelivered code list, and the modifiers of delivered code.

[0060] In the technical solution provided by this invention, the acquired delivery information table and submission information table are matched to generate a list of undelivered code; the modifiers of the delivered code are matched according to the development mode; and a monitoring list is generated based on the generated hierarchical code list, the list of undelivered code, and the modifiers of the delivered code. This enables accurate monitoring of undelivered code and improves the accuracy and efficiency of monitoring.

[0061] Figure 2 A flowchart of another method for monitoring undelivered code provided in an embodiment of the present invention is shown below. Figure 2 As shown, the method includes:

[0062] Step 201: Match the obtained delivery information table and submission information table to generate a list of undelivered code.

[0063] In this embodiment of the invention, each step is performed by an undelivered code monitoring device.

[0064] In this embodiment of the invention, the delivery information table is obtained from the continuous delivery pipeline, which stores relevant information for each delivery version. The delivery information table includes, but is not limited to, artifact number, version delivery information, and target baseline. Version delivery information includes version plan, application, and service group. After a version is successfully delivered in the continuous delivery pipeline, it is stored in the artifact library, and a corresponding artifact number is generated. If a modified version is subsequently delivered, a modified artifact number is generated, and the modified artifact number is greater than the previous version's artifact number.

[0065] In this embodiment of the invention, the commit information table can be obtained from the git database, and the commit information table includes, but is not limited to, application, code commit time, committer, repository, and branch.

[0066] In this embodiment of the invention, step 201 specifically includes:

[0067] Step 2011: Determine the final delivery version based on the delivery information sheet.

[0068] In this embodiment of the invention, the delivery information table includes multiple delivered artifact versions, where a larger artifact number indicates a newer version. Specifically, multiple artifact numbers with the same version delivery information are obtained from the delivery information table; the version delivery information corresponding to the largest artifact number is taken as the final delivered version. The version delivery information includes version plan, service group, and application; artifacts with the same version delivery information are considered the same artifact.

[0069] Step 2012: Match the target baseline of the final delivery version with the commit information table to generate a list of undelivered code.

[0070] In this embodiment of the invention, the commit information table includes, but is not limited to, the application, repository, branch, code commit time, code name and path, and committer. The commit information table can be obtained from the Git database.

[0071] Specifically, the target baseline is parsed to generate baseline information, which includes the application, repository, branch, and packaging time. The application, repository, and branch in the commit information table are matched with those in the baseline information to identify the packaging time and code commit time for the same application, repository, and branch. The packaging time and code commit time are compared, and code commit times later than the packaging time are identified as undeliverable. Based on the undeliverable information, a list of undeliverable code is generated. The same application, repository, and branch indicate the same artifact. The packaging time and code commit time of the same artifact are compared; if code with a commit time later than the packaging time exists, it indicates that the code was modified and packaged after the last delivered version was committed, and is therefore undeliverable code. Based on the undeliverable code, a list of undeliverable code is generated.

[0072] Figure 3 This invention provides a logical diagram illustrating the accurate acquisition of a list of undelivered code, as shown in the embodiment of the invention. Figure 3 As shown, the process first retrieves a delivery information table from the continuous delivery pipeline. This table includes multiple delivered artifact versions and corresponding version delivery information, including but not limited to version plans, service groups, and applications. Delivery versions with identical version plans, service groups, and applications are identified as the final delivery versions. Each delivery version includes the application and a target baseline. The target baseline is parsed to generate a repository, branch, and packaging time. The application, repository, branch, code commit time, code name and path, and committer are retrieved from the Git database. The application, repository, and branch are matched with those in the baseline information to identify the packaging time and code commit time for identical applications, repositories, and branches. The packaging time and code commit time are compared to generate a list of undelivered code.

[0073] Step 202: Based on the development model, identify the person who modified the delivered code.

[0074] In this embodiment of the invention, the development modes include a monthly development mode and a feature development mode. The undelivered code monitoring method provided in this embodiment is compatible with both the monthly development mode and the feature development mode, and has strong versatility. It is necessary to identify situations where code is added to the feature branch but not synchronized to the release branch, where the code modifier is the person who modified the code in the last version synchronized to the release branch. To accurately match the modifier, the following scenarios need to be considered:

[0075] Figure 4This is a schematic diagram of a code modification scenario provided by an embodiment of the present invention, such as... Figure 4 As shown, modifier a made changes at node 1 on the feature branch, and the changes were synchronized to node 1 on the release branch; modifier b made changes at node 2 on the feature branch, and the changes were synchronized to node 2 on the release branch; modifier c made changes at node 3 on the feature branch, but the changes were not synchronized to the release branch. Therefore, modifier b is the last modifier to deliver the code.

[0076] Figure 5 This is a schematic diagram illustrating another code modification scenario provided by an embodiment of the present invention, such as... Figure 5 As shown, when multiple people modify the same code and synchronize it to the release branch, the last person to make the changes synchronized to the release branch is considered the person who delivered the code. Modifier A makes changes at node 1 on the feature branch and synchronizes the changes to node 1 on the release branch. Modifiers B, C, and D make changes at nodes 2, 3, and 4 on the feature branch, respectively. After modifier D finishes making changes, the changes are synchronized to node 4 on the release branch. Therefore, modifier D is the last person to deliver the code.

[0077] Figure 6 This is a schematic diagram illustrating another code modification scenario provided by an embodiment of the present invention, such as... Figure 6 As shown, modifier a makes a modification on node 1 of the feature branch, and the modification is synchronized to node 1 of the release branch; modifier b makes modifications on nodes 2 and 3 of the feature branch again, and the modification is synchronized to node 3 of the release branch; modifier c makes modifications on nodes 4 and 5 of the feature branch again, and the modification is synchronized to node 5 of the release branch. Therefore, modifier c is the last modifier to deliver the code.

[0078] Specifically, if the development mode is monthly and the code is directly added to the package branch, the corresponding modifier is retrieved from the commit information table based on the undelivered code list. For example, if the committer in the commit information table of the Git database is gmp, then gmp is identified as the modifier who delivered the code.

[0079] If the development mode is feature-based, the branches in the commit information table are feature branches, and the branches in the delivery information table are release branches. Specifically, obtain at least one candidate modifier corresponding to the parent node of the node in the undelivered code list on the release branch. The parent node is located on the feature branch, and each candidate modifier has a corresponding code commit time. Compare each code commit time with the node's packaging time, and filter out at least one candidate modifier whose code commit time is less than the packaging time. From the code commit times of at least one candidate modifier, select the maximum value, and determine the candidate modifier corresponding to the maximum value as the modifier who will deliver the code. The parent node corresponding to the node in the release branch can be matched from the feature branch using "code name + path + repository + branch + application". For example, if node 5 is on the release branch, the parent node on the feature branch is matched to be 5, and the corresponding committer is c. Submitter c is determined as the modifier who will deliver the code.

[0080] Step 203: Obtain the repository from the undelivered code list.

[0081] In this embodiment of the invention, the repositories in the undelivered code list can be obtained from the Git database. The same repository includes production code and test code; production code requires higher priority from developers compared to test code.

[0082] Step 204: Determine if the specified test directory exists in the repository. If yes, proceed to step 205; otherwise, proceed to step 207.

[0083] In this embodiment of the invention, according to the central test code storage requirements, the test code in the repository is stored in a designated test directory. As an optional solution, the designated test directory is the "test" directory. Specifically, it is determined whether the "test" directory exists in the repository. If it does, it indicates that the repository contains test code, and step 205 is executed; if not, it indicates that the repository does not contain test code, and step 207 is executed.

[0084] Step 205: Store the code in the specified test directory as a test code listing, and store the code in directories other than the specified test directory as a production code listing.

[0085] In this embodiment of the invention, the code in the `test` directory is test code, and the code in other directories is production code. Specifically, the code in the `test` directory is stored as a test code list, and the code in other directories is stored as a production code list. As an optional solution, test code and production code can be displayed through different worksheets, thereby separating production code from test code and facilitating efficient processing of different types of code by developers.

[0086] Step 206: Generate a hierarchical code list based on the test code list and the production code list, and continue to step 208.

[0087] In this embodiment of the invention, the hierarchical code list is a list of different types of code that are distinguished, including a test code list and a production code list, and then proceed to step 208.

[0088] Step 207: Generate a list of hierarchical codes.

[0089] In this embodiment of the invention, if the version repository does not contain test code, then the code in the version repository is determined as production code, and the code in the test code list in the hierarchical code list is empty.

[0090] Step 208: Generate a monitoring list based on the generated hierarchical code list, undelivered code list, and the modifiers of delivered code.

[0091] Step 209: Issue warnings to the monitoring list by specifying the warning method.

[0092] In this embodiment of the invention, the specified early warning method can be set according to the actual situation, and this embodiment of the invention does not limit it. As an optional solution, the early warning method is email. Specifically, the monitoring list is sent to designated staff via email so that the designated staff can monitor and issue early warnings for the list of undelivered code.

[0093] In this embodiment of the invention, the undelivered code list and the modifier can be accurately obtained simply by using the delivered version information and the submission information form. The operation is simple, and the latest undelivered code list can be obtained based on the delivered versions in the continuous delivery pipeline, which is highly timely. This embodiment of the invention obtains the undelivered code list at the code level, which ensures the accuracy of the undelivered code list. The monitoring list is automatically sent to staff via email for timely warning, saving manpower costs and improving warning efficiency.

[0094] In the technical solution of the non-delivered code monitoring method provided in this embodiment of the invention, the acquired delivery information table and submission information table are matched to generate a non-delivered code list; the modifier of the delivered code is matched according to the development mode; and a monitoring list is generated based on the generated hierarchical code list, non-delivered code list and modifier of delivered code, which can accurately monitor non-delivered code and improve the accuracy and efficiency of monitoring.

[0095] Figure 7 This is a schematic diagram of an undelivered code monitoring device provided in an embodiment of the present invention. This device is used to execute the aforementioned undelivered code monitoring method, such as... Figure 7 As shown, the device includes: a first matching unit 11, a second matching unit 12, and a first generation unit 13.

[0096] The first matching unit 11 is used to match the obtained delivery information table and submission information table to generate a list of undelivered codes.

[0097] The second matching unit 12 is used to match the modifier of the delivered code based on the development mode.

[0098] The first generation unit 13 is used to generate a monitoring list based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered code.

[0099] In this embodiment of the invention, the first matching unit 11 is specifically used to determine the final delivery version based on the delivery information table; match the target baseline of the final delivery version with the submission information table to generate a list of undelivered code.

[0100] In this embodiment of the invention, the first matching unit 11 is specifically used to obtain multiple product numbers with the same version delivery information from the delivery information table; and to take the version delivery information corresponding to the largest product number as the final delivery version.

[0101] In this embodiment of the invention, the first matching unit 11 is specifically used to parse the target baseline and generate baseline information, which includes the application, repository, branch, and packaging time; match the application, repository, and branch in the commit information table with the application, repository, and branch in the baseline information, and match the packaging time and code commit time corresponding to the same application, repository, and branch; compare the packaging time and code commit time, and determine the information where the code commit time is later than the packaging time as undelivered information; and generate an undelivered code list based on the undelivered information.

[0102] In this embodiment of the invention, the second matching unit 12 is specifically used to query the corresponding modifier from the submission information table based on the undelivered code list.

[0103] In this embodiment of the invention, the second matching unit 12 is specifically used to obtain at least one candidate modifier corresponding to the parent node of the node on the release branch of the undelivered code list. The parent node is located on the feature branch, and each candidate modifier corresponds to a code submission time. The code submission time of each candidate modifier is compared with the packaging time of the node, and at least one candidate modifier corresponding to the code submission time being less than the packaging time is selected. The maximum value is selected from the code submission times of at least one candidate modifier, and the candidate modifier corresponding to the maximum value is determined as the modifier of the delivered code.

[0104] In this embodiment of the invention, the device further includes: an acquisition unit 14, a judgment unit 15, a classification unit 16, and a second generation unit 17.

[0105] Unit 14 is used to retrieve the repository from the undelivered code list.

[0106] The judgment unit 15 is used to determine whether the specified test directory exists in the version repository.

[0107] The hierarchical unit 16 is used to store the code in the specified test directory as a test code listing if the judgment unit 15 determines that the specified test directory exists in the version repository, and to store the code in directories other than the specified test directory as a production code listing.

[0108] The second generation unit 17 is used to generate a hierarchical code list based on the test code list and the production code list.

[0109] In this embodiment of the invention, the device further includes an early warning unit 18.

[0110] The early warning unit 18 is used to issue early warnings to the monitoring list by specifying an early warning method.

[0111] In the solution of this invention embodiment, the obtained delivery information table and submission information table are matched to generate a list of undelivered code; the modifiers of the delivered code are matched according to the development mode; and a monitoring list is generated based on the generated hierarchical code list, the list of undelivered code, and the modifiers of the delivered code, which can accurately monitor undelivered code and improve the accuracy and efficiency of monitoring.

[0112] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer device, specifically, a computer device can be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or any combination of these devices.

[0113] This invention provides a computer device including a memory and a processor. The memory is used to store information including program instructions, and the processor is used to control the execution of the program instructions. When the program instructions are loaded and executed by the processor, they implement the steps of the above-described embodiment of the non-delivered code monitoring method. For a detailed description, please refer to the above-described embodiment of the non-delivered code monitoring method.

[0114] The following is for reference. Figure 8 It shows a schematic diagram of the structure of a computer device 600 suitable for implementing the embodiments of this application.

[0115] like Figure 8As shown, the computer device 600 includes a central processing unit (CPU) 601, which can perform various appropriate tasks and processes according to programs stored in read-only memory (ROM) 602 or programs loaded from storage section 608 into random access memory (RAM) 603. The RAM 603 also stores various programs and data required for the operation of the computer device 600. The CPU 601, ROM 602, and RAM 603 are interconnected via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0116] The following components are connected to I / O interface 605: an input section 606 including a keyboard, mouse, etc.; an output section 607 including a cathode ray tube (CRT), liquid crystal feedback (LCD), etc., and speakers, etc.; a storage section 608 including a hard disk, etc.; and a communication section 609 including a network interface card such as a LAN card, modem, etc. The communication section 609 performs communication processing via a network such as the Internet. A drive 610 is also connected to I / O interface 605 as needed. A removable medium 611, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on drive 610 as needed so that computer programs read from it can be installed in storage section 608 as needed.

[0117] In particular, according to embodiments of the present invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present invention include a computer program product comprising a computer program tangibly embodied on a machine-readable medium, the computer program including program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 609, and / or installed from removable medium 611.

[0118] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0119] For ease of description, the above devices are described separately by function as various units. Of course, in implementing this application, the functions of each unit can be implemented in one or more software and / or hardware.

[0120] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0121] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0122] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0123] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0124] The acquisition, storage, use, and processing of data in this application all comply with the relevant provisions of national laws and regulations.

[0125] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0126] This application can be described in the general context of computer-executable instructions, such as program modules, that are executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. This application can also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0127] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on describing the differences from other embodiments. In particular, the system embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments.

[0128] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. A method for monitoring undelivered code, characterized in that, The method includes: The obtained delivery information table and submission information table are matched to generate a list of undelivered code; Based on the development model, identify the person who modified the delivered code; A monitoring list is generated based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered codes; The development mode is a feature development mode, the branch in the submission information table is a feature branch, and the branch in the delivery information table is a release branch. The process of matching the modifiers of the delivered code based on the development model includes: Get at least one candidate modifier corresponding to the parent node of the node in the undelivered code list on the release branch. The parent node is located on the feature branch, and each candidate modifier has a code commit time. Compare the code submission time with the node's packaging time, and filter out at least one candidate modifier whose code submission time is less than the packaging time; The maximum value is selected from the code submission times of at least one candidate modifier, and the candidate modifier corresponding to the maximum value is determined as the modifier of the delivered code; wherein, the modifier of the delivered code is the modifier of the delivered code; The process of generating the monitoring list based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered code also includes: Retrieve the repositories from the undelivered code list; Determine whether the specified test directory exists in the repository; If so, store the code in the specified test directory as a test code listing, and store the code in directories other than the specified test directory as a production code listing; Based on the test code list and the production code list, generate a hierarchical code list; The hierarchical code listing is a code listing that distinguishes different types of listings, including test code listings and production code listings; The parent node is the parent node that is matched from the feature branch and corresponds to the node of the release branch by the code name, path, version library, branch, and application.

2. The method for monitoring undelivered code according to claim 1, characterized in that, The delivery information table includes the product number, version delivery information, and destination baseline; The process of matching the obtained delivery information table and submission information table to generate a list of undelivered code includes: The final delivery version is determined based on the aforementioned delivery information table; The final delivery version's target baseline is matched with the commit information table to generate the undelivered code list.

3. The method for monitoring undelivered code according to claim 2, characterized in that, Determining the final delivery version based on the delivery information table includes: Retrieve multiple product numbers with the same version of delivery information from the delivery information table; The version delivery information corresponding to the largest product number is taken as the final delivery version.

4. The method for monitoring undelivered code according to claim 2, characterized in that, The submission information table includes the application, repository, branch, and code submission time; The step of matching the target baseline of the final delivery version with the commit information table to generate the undelivered code list includes: The target baseline is parsed to generate baseline information, which includes the application, repository, branch, and packaging time. The application, repository, and branch in the commit information table are matched with the application, repository, and branch in the baseline information to find the packaging time and code commit time corresponding to the same application, repository, and branch. The packaging time and code submission time are compared, and information where the code submission time is later than the packaging time is determined as undelivered information. Based on the undelivered information, a list of undelivered codes is generated.

5. The method for monitoring undelivered code according to claim 1, characterized in that, The development mode described is a monthly development mode; The process of matching the modifiers of the delivered code based on the development model includes: Based on the list of undelivered code, the corresponding modifier is retrieved from the submission information table.

6. The method for monitoring undelivered code according to claim 1, characterized in that, After generating the monitoring list based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered code, the process further includes: The monitoring list is alerted by specifying an alert method.

7. A device for monitoring undelivered code, characterized in that, The device includes: The first matching unit is used to match the obtained delivery information table and submission information table to generate a list of undelivered code; The second matching unit is used to match the person who modified the delivered code based on the development mode; The generation unit is used to generate a monitoring list based on the generated hierarchical code list, the undelivered code list, and the modifiers of the delivered code; The development mode is a feature development mode, the branch in the submission information table is a feature branch, and the branch in the delivery information table is a release branch. The second matching unit is specifically used to obtain at least one candidate modifier corresponding to the parent node of the node in the undelivered code list on the release branch. The parent node is located on the feature branch, and each candidate modifier has a corresponding code commit time. The code commit time of each candidate modifier is compared with the packaging time of the node, and at least one candidate modifier corresponding to the code commit time being less than the packaging time is selected. The maximum value is selected from the code commit times of the at least one candidate modifier, and the candidate modifier corresponding to the maximum value is determined as the modifier of the delivered code. The modifier of the delivered code is the modifier of the delivered code. The device further includes: The retrieval unit is used to retrieve the repository from the undelivered code manifest; The decision unit is used to determine whether the specified test directory exists in the repository. The hierarchical unit is used to store the code in the specified test directory as a test code listing if the judgment unit determines that the specified test directory exists in the version repository, and to store the code in directories other than the specified test directory as a production code listing. The second generation unit is used to generate a hierarchical code list based on the test code list and the production code list; The hierarchical code listing is a code listing that distinguishes different types of listings, including test code listings and production code listings; The parent node is the parent node that is matched from the feature branch and corresponds to the node of the release branch by the code name, path, version library, branch, and application.

8. A computer-readable medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the undelivered code monitoring method as described in any one of claims 1 to 6.

9. A computer device comprising a memory and a processor, the memory for storing information including program instructions, and the processor for controlling the execution of the program instructions, characterized in that, When the program instructions are loaded and executed by the processor, the undelivered code monitoring method as described in any one of claims 1 to 6 is implemented.

Images