CN113220279A

CN113220279A - Code index management method, device, equipment and medium

Info

Publication number: CN113220279A
Application number: CN202010072041.7A
Authority: CN
Inventors: 王亚伟; 叶巍; 王谦
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Cloud Computing Technologies Co Ltd
Priority date: 2020-01-21
Filing date: 2020-01-21
Publication date: 2021-08-06

Abstract

The application provides a code index management method, which comprises the following steps: the remote code warehouse receives the codes submitted by the code version control device, the indexing device acquires the codes from the remote code warehouse, then creates full indexes of the codes according to the codes, stores the full indexes of the codes, the remote code warehouse sends the codes to the integrated development device, and the indexing device sends the full indexes of the codes to the integrated development device. Therefore, the problem that the integrated development device carries out full indexing locally to occupy local system resources is solved, and the lightweight integrated development device can also be used for large-scale program development. Also, the time taken to index the code is saved.

Description

Code index management method, device, equipment and medium

Technical Field

The present application relates to the field of computer technologies, and in particular, to a code index management method, apparatus, device, and computer-readable storage medium.

Background

In developing programs, developers often use Integrated Development Environments (IDEs) for implementation. An IDE is an application program that provides a program development environment and typically includes tools such as an editor, a compiler, a debugger, and a graphical user interface.

Currently, IDE is developed to support multiple programming languages, such as C, Java, Python, etc. To this end, the industry provides an IDE architecture that includes a host process and a plurality of extension processes. The extension process includes a Language Server (LS). The editor does not need to support each language, only needs to support a Language Server Protocol (LSP), namely, all languages supporting the LSP can be supported in the editor at the same level through the interaction between the LSP and the language server, and the problem of compatibility between the editor and a programming language is solved.

The language server provides a series of general functions for the languages supported by the language server, specifically including reference query, jump to variable declaration, jump to function declaration, jump to class declaration and the like. The language server relies on the code index to implement the above-described functionality. By code index is meant metadata of objects in the code that can be indexed. The conventional IDE often takes a lot of time to index codes, and the index success rate is low, so that a large program cannot be developed.

Disclosure of Invention

The application provides a code index management method, which solves the problems that the IDE needs to spend a large amount of time when carrying out code index, and the index success rate is low, so that a large program cannot be developed. Corresponding apparatus, devices, computer-readable storage media, and computer program products are also provided.

In a first aspect, the present application provides a code index management method, which is applied to a code index management system. The code index management system comprises an indexing device and a remote code warehouse. Specifically, the remote code repository receives the code submitted by the code versioning apparatus, and the indexing apparatus may acquire the code from the remote code repository, then create a full index of the code from the code, and store the full index of the code. When a developer acquires the codes from the remote code warehouse to the integrated development device for development, the indexing device can index the full amount of the codes to the integrated development device.

Therefore, the integrated development device does not need to carry out full index on the codes locally, and only needs to receive the full index sent by the indexing device, so that the problem that the integrated development device occupies a large amount of local system resources when carrying out code indexing is solved, and the indexing success rate is improved. Moreover, the time for receiving the full index by the integrated development device is far shorter than the time for creating the full index, so that the time spent on indexing the codes is saved, and the indexing efficiency is improved. Because the resource occupation is less and the time consumption is less, the light-weight integrated development device can be suitable for large-scale program development, and the usability is improved.

In some possible implementations, in order to enable the integrated development device to obtain the index of the code in time after obtaining the code, so that the developer obtains a better development experience, the indexing device may create a full index of the code before the integrated development device receives the code. Therefore, the condition that the index of the integrated development device fails due to the fact that the full index of the codes which are not stored in the index device is used can be avoided, and development experience is improved.

In some possible implementations, the remote code repository also stores a submission identification of the code. The commit identifier is used to distinguish codes corresponding to different commit operations, and in a specific implementation, the commit identifier may be obtained by performing hash calculation based on the codes, that is, the commit identifier (commit ID) may be a commit hash value (commit hash) obtained by performing hash calculation on the codes.

Correspondingly, the indexing device also stores the corresponding relation between the submission identification of the code and the full-scale index of the code. When the remote code warehouse sends the codes, the submission identification of the codes can be sent to the integrated development device together. The integrated development device can send an index acquisition request to the indexing device, wherein the index acquisition request comprises a submission identifier of the code. In this way, the indexing device can send the full index of the code to the integrated development device according to the submission identification of the code.

In some possible implementations, the developer may also make changes to the code pulled from the remote code repository. For example, code may be added to implement new functionality or new features. The code may also be modified, for example, to ameliorate code defects. Of course, codes may also be deleted to eliminate unnecessary functions or features.

Based on this, the integrated development device may receive change settings for the code, obtain changed code, create a delta index from the changed code before submitting the changed code to the remote code repository, and store the changed code and the delta index corresponding to the changed code.

The full index refers to creating an index for all submitted codes, and the delta index refers to creating an index for modified codes on the basis of the last version. The resource overhead of carrying out incremental indexing locally is far less than that of carrying out full indexing locally, so that the problem that a large amount of local system resources are occupied by the indexing service is solved. And when the program is cooperatively developed by multiple persons, each developer only carries out incremental indexing when the local code is changed, so that the indexing time is greatly reduced, and the indexing efficiency is improved.

In some possible implementations, the developer may restart the IDE in consideration of possible interruption of the program development process, for example, the developer has other transactions to interrupt the program development process, or an exception occurs in the current program development project to interrupt the program development process. Based on this, the IDE can refresh the index stored in the IDE according to the full amount of indexes stored by the indexing device. In addition, when the language service generates an error, the IDE may also refresh the index stored in the IDE according to the full index stored by the indexing device. The developer may also configure a refresh cycle by which the IDE may refresh the index stored in the IDE based on the full index stored by the indexing device. The stability and reliability of the index service can be improved by refreshing the index stored in the IDE.

Specifically, the integrated development device may send a submit identification query request to the indexing device. The submitted identification query request comprises an identification list formed by submitted identifications stored by the integrated development device. And the indexing device determines a submission identifier submitted to the remote code warehouse latest according to the identifier list, and returns the submission identifier submitted to the remote code warehouse latest to the integrated development device. And the integrated development device acquires a target index according to the latest submission identifier submitted to the remote code warehouse, wherein the target index is an index corresponding to the code submitted to the remote code warehouse by the integrated development device and is not stored by the integrated development device.

In some possible implementations, the submitted identifier query request includes an identifier list formed by N submitted identifiers with a front submission time in the submitted identifiers stored in the integrated development device, where N is a positive integer.

When the index device determines the latest submission identifier submitted to the remote code repository according to the identifier list formed by the submission identifiers stored in the integrated development device, the index device may sequentially query whether the N submission identifiers exist in the submission identifiers stored in the index device. If so, the indexing device may determine that the submission identifier of the first successful query is the latest submission identifier submitted to the remote code repository. If not, the integrated development device is instructed to send the next submitted identification query request until the index device queries that the submitted identification included in the submitted identification query request exists in the submitted identification stored in the index device.

The next submitted identifier query request comprises M submitted identifiers with the submitting time after the submitting time of the submitted identifier included in the current submitted identifier query request, wherein M is larger than or equal to N, so that the query efficiency can be improved. In some possible implementations, M may be 2 times N.

In a second aspect, the present application provides a code index management method, which is applied to an index device. Specifically, after a remote code repository receives submitted codes, the indexing device may retrieve the codes from the remote code repository, and then the indexing device may create a full index of the codes from the codes, storing the full index of the codes. Then, the indexing device receives an index acquisition request sent by the integrated development device, the index acquisition request is used for requesting a full index of the code, and then the indexing device sends the full index of the code to the integrated development device according to the index acquisition request. Therefore, the method avoids the situation that the integrated development device locally creates a full index to occupy a large amount of local system resources, and improves the index success rate. And because the full index does not need to be created locally, the time required by the index is saved.

In some possible implementations, the indexing device may create a full index of the code before the integrated development device sends the index acquisition request. Therefore, the condition that the index of the integrated development device fails due to the fact that the full index of the codes which are not stored in the index device is used can be avoided, and development experience is improved.

In some possible implementations, the method further includes:

the index device receives a submitted identification query request from the integrated development device, wherein the submitted identification query request comprises an identification list formed by submitted identifications stored by the integrated development device;

the indexing device determines a submission identifier which is submitted to the remote code warehouse latest according to the identifier list;

and returning the latest submission identifier submitted to the remote code warehouse to the integrated development device, so that the integrated development device acquires a target index according to the latest submission identifier submitted to the remote code warehouse, wherein the target index is an index corresponding to the code submitted to the remote code warehouse by the integrated development device and is not stored by the integrated development device.

In some possible implementations, the submitted identifier query request includes an identifier list formed by N submitted identifiers whose submission times are earlier in the submitted identifiers stored in the integrated development device, where N is a positive integer;

the index device determines a submission identifier newly submitted to the remote code warehouse according to an identifier list formed by the submission identifiers stored by the integrated development device, and the method comprises the following steps:

the indexing device sequentially inquires whether the N submission identifications exist in the submission identifications stored by the indexing device;

if not, the integrated development device is instructed to send a next submitted identification query request until the index device queries that the submitted identification included in the submitted identification query request exists in the submitted identification stored by the index device, the next submitted identification query request includes M submitted identifications with the submitting time after the submitting time of the submitted identification included in the current submitted identification query request, and M is larger than or equal to N.

In a third aspect, the present application provides a code index management method, which is applied to an integrated development device. Specifically, the integrated development device acquires code stored in a remote code repository and a submission identifier of the code. And then the integrated development device sends an index acquisition request to the indexing device, wherein the index acquisition request comprises the submission identifier. The index device stores the corresponding relation between the full index of the code and the submission identifier of the code. Therefore, the integrated development device can receive the full index of the code determined by the indexing device according to the submission identifier of the code, so that the integrated development device is prevented from occupying a large amount of local system resources due to the fact that the integrated development device creates the full index locally, and the indexing success rate is improved. And because the full index does not need to be created locally, the time required by the index is saved.

In some possible implementations, the method further includes:

the integrated development device receives the changed setting of the code and obtains the changed code;

before the modified code is submitted to the remote code repository, the integrated development device creates a delta index from the modified code, stores the modified code and the delta index corresponding to the modified code.

In some possible implementations, the method further includes:

the integrated development device sends a submitted identification query request to the index device, wherein the submitted identification query request comprises an identification list formed by submitted identifications stored by the integrated development device;

the integrated development device receives a submission identifier which is determined by the indexing device according to the identifier list and is submitted to the remote code warehouse latest;

and the integrated development device acquires a target index according to the latest submission identifier submitted to the remote code warehouse, wherein the target index is an index corresponding to the code submitted to the remote code warehouse by the integrated development device and is not stored by the integrated development device.

In a fourth aspect, the present application provides a code index management system, including:

the remote code warehouse is used for receiving the codes submitted by the code version control device;

the indexing device is used for acquiring the codes from the remote code warehouse, creating a full index of the codes according to the codes and storing the full index of the codes;

the remote code warehouse is also used for sending the codes to an integrated development device;

the indexing device is further used for sending the full-scale index of the codes to the integrated development device.

In some possible implementations, the indexing device is specifically configured to:

creating a full index of the code before the integrated development device receives the code.

In some possible implementations, the remote code repository further stores a submission identifier of the code, and the indexing device further stores a correspondence between the submission identifier of the code and the full-scale index of the code;

the remote code repository is specifically configured to:

sending the code and the submission identifier of the code to an integrated development device;

the code index management system further includes:

the integrated development device is used for sending an index acquisition request to the indexing device, wherein the index acquisition request comprises the submission identifier of the code;

the indexing means is specifically configured to:

and sending the full index of the code to the integrated development device according to the submission identification of the code.

In some possible implementations, the integrated development device is further configured to:

receiving the change setting of the code to obtain a changed code;

creating a delta index from the altered code prior to submitting the altered code to the remote code repository, storing the altered code and the delta index corresponding to the altered code.

sending a submitted identification query request to the indexing device, wherein the submitted identification query request comprises an identification list formed by submitted identifications stored by the integrated development device;

receiving a submission identifier which is determined by the indexing device according to the identifier list and is submitted to the remote code warehouse latest;

and acquiring a target index according to the latest submission identifier submitted to the remote code warehouse, wherein the target index is an index corresponding to the code submitted to the remote code warehouse by the integrated development device and is not stored by the integrated development device.

In a fifth aspect, the present application provides an indexing device, comprising:

a communication module for obtaining the code from a remote code repository;

the index creating module is used for creating a full index of the code according to the code;

the storage module is used for storing the full index of the code;

the communication module is further used for sending the full index of the codes to the integrated development device.

The index creation module is specifically configured to:

in some possible implementations, a full index of the code is created before the integrated development device receives the code.

In some possible implementations, the remote code repository further stores a submission identifier of the code, and the storage module further stores a correspondence between the submission identifier of the code and the full-scale index of the code;

the communication module is further configured to:

receiving an index acquisition request from an integrated development device, wherein the index acquisition request comprises a submission identifier of the code;

In some possible implementations, the apparatus further includes an index management module;

the communication module is further configured to receive a submitted identifier query request from the integrated development device, where the submitted identifier query request includes an identifier list formed by submitted identifiers stored in the integrated development device;

the index management module is used for determining a submission identifier which is submitted to the remote code warehouse latest according to the identifier list;

the communication module is further configured to return the latest submission identifier submitted to the remote code repository to the integrated development device, so that the integrated development device obtains a target index according to the latest submission identifier submitted to the remote code repository, where the target index is an index corresponding to a code submitted to the remote code repository by the integrated development device and is not stored by the integrated development device.

the index management module is specifically configured to:

sequentially inquiring whether the N submission identifications exist in the submission identifications stored in the indexing device;

In a sixth aspect, the present application provides an integrated development device, the device comprising:

the communication module is used for receiving codes sent by the remote code warehouse and receiving full indexes of the codes sent by the indexing device;

and the storage module is used for storing the codes and the full-scale indexes of the codes.

the communication module is further configured to:

and sending an index acquisition request to the indexing device, wherein the index acquisition request comprises the submission identification of the code, so that the indexing device sends the full index of the code according to the submission identification of the code.

In some possible implementations, the apparatus further includes:

the basic development module is used for receiving the change setting of the codes by the integrated development device to obtain changed codes;

a language service module for creating an increment index according to the modified code before submitting the modified code to the remote code repository, and storing the modified code and the increment index corresponding to the modified code.

In some possible implementations, the communication module is further configured to:

In a seventh aspect, the present application provides an apparatus comprising a processor and a memory;

the processor is configured to execute the instructions stored in the memory to perform the code index management method according to the second aspect of the present application.

In an eighth aspect, the present application provides an apparatus comprising a processor and a memory;

the processor is configured to execute the instructions stored in the memory to perform the code index management method according to the third aspect of the present application.

In a ninth aspect, the present application provides a computer-readable storage medium comprising instructions that, when executed on a device, cause the device to perform the code index management method according to the second aspect.

In a tenth aspect, the present application provides a computer-readable storage medium comprising instructions that, when executed on a device, cause the device to perform the code index management method according to the third aspect.

In an eleventh aspect, the present application provides a computer program product containing instructions that, when run on a device, cause the device to perform the code index management method of the second aspect or any implementation manner of the second aspect.

In a twelfth aspect, the present application provides a computer program product containing instructions that, when run on a device, cause the device to perform the code index management method according to the third aspect or any implementation manner of the third aspect.

The present application can further combine to provide more implementations on the basis of the implementations provided by the above aspects.

Drawings

In order to more clearly illustrate the technical method of the embodiments of the present application, the drawings used in the embodiments will be briefly described below.

Fig. 1 is a schematic diagram of a code file and an index file provided in an embodiment of the present application;

FIG. 2 is an architecture diagram of a code index management system according to an embodiment of the present application;

fig. 3 is a schematic view of an application scenario of a code index management system according to an embodiment of the present application;

fig. 4 is a schematic view of an application scenario of a code index management system according to an embodiment of the present application;

FIG. 5 is an interaction flowchart of a code index management method according to an embodiment of the present application;

FIG. 6 is an interaction flowchart of a code index management method according to an embodiment of the present application;

FIG. 7 is a diagram illustrating refreshing an index stored in an integrated development device according to a full index according to an embodiment of the present application;

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

fig. 9 is a schematic structural diagram of an apparatus according to an embodiment of the present application.

Detailed Description

The scheme in the embodiments provided in the present application will be described below with reference to the drawings in the present application.

The terms "first," "second," and the like in the description and in the claims of the present application and in the above-described drawings are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the terms so used are interchangeable under appropriate circumstances and are merely descriptive of the various embodiments of the application and how objects of the same nature can be distinguished.

In order to facilitate understanding of the technical solutions of the present application, some technical terms related to the present application are first described.

An Integrated Development Environment (IDE), also called an integrated development device, is used to provide a program development environment for developers. In particular, the IDE may provide the basic functionality for program development. In one example, the basic functionality may specifically include at least one of code editing, file reading, and debugging. The IDE also provides the functions related to the programming language in order to improve the editing efficiency. In one example, the functionality associated with the programming language may be functionality to understand code, including understanding the meaning of the code as expressed, such as a function, variable, class, or interface, and so forth.

Considering the situation that a developer performs program development by using different programming languages, the IDE may decouple the functions related to the programming languages from the IDE, so that the editor of the IDE need not support each programming language, and only needs to support a Language Service Protocol (LSP), and can support different programming languages through a Language Server (LS).

The IDE can realize functions of grammar check, lexical check, reference inquiry, automatic completion and the like aiming at different programming languages through the LS. For example, when a developer edits code using the IDE, if a variable sayhello is predefined, the IDE may prompt that sayhello is occupied when defining a function sayhello, and the developer may rename the above function, such as named sayhi, and thus implement syntax checking. For another example, when a developer edits a code by using the IDE, if the say is typed, the IDE can prompt a plurality of candidates, such as a variable sayhello, a function sayhi, and the like, so that the developer selects one of the candidates to realize automatic completion, thereby avoiding tedious typing operation.

The IDE is implemented by an index (index) that depends on an indexable object in a code file when implementing functions such as syntax checking, lexical checking, reference querying, or auto-completion. The indexable object is specifically an identifier (symbol) in a code file. As one example, an indexable object can be a variable (var), a constant (const), or a function (function) in a code file, among others. The index specifically refers to metadata (metadata) of an indexable object. Metadata is data describing data, and is data describing an indexable object as specific to the present application.

In one example, the index may include at least one of a declaration (declaration) and a location of the identifier described above. Wherein the declaration is used to inform the compiler about the identifier. Taking a function as an example, the declaration of the function may include a function name, a parameter type, and a parameter, and one format and a corresponding example of the declaration of the function are shown below:

return type function name (parameter 1 type parameter 1, parameter 2 type parameter 2, … …);

int add(int x，int y)；

for the convenience of understanding, the present application also illustrates a code file and an index of an indexable object in the code file in conjunction with the drawings.

As shown in fig. 1, the code file includes at least one statement, and may specifically include at least one of a function declaration statement, a function definition statement, a variable declaration statement, a constant definition statement, and a constant declaration statement. For external functions (functions defined in other code files) and standard input-output functions, the corresponding functions may be declared in a way of declaration files. For a variable or constant, it implements a definition when it is declared.

An index for an indexable object in a code file can be stored in an index file. The index specifically includes the declaration and location of the identifiers included in the code file shown in fig. 1. Wherein, the declaration of the identifier is at least one of function declaration, variable declaration and constant declaration. The location of the identifier may be characterized based on the row number (row) and column number (column) of the identifier in the code file.

Fig. 1 provides a sample of code files including identifiers of variable c, function pow2, function printf, etc., where the function pow2 is defined in other code files, i.e., other.h., and the function printf is defined in the standard input-output file stdio.h. The developer can embed header files such as other.h and stdio.h by including an instruction include to declare the function pow2 and the function printf described above. Correspondingly, fig. 1 also provides an index file of the sample code file, where the index file includes the declaration of the variable c and the row and column numbers of the variable c, the declaration of the function pow2 and the row and column numbers of the function pow2, and the declaration of the function printf and the row and column numbers.

It should be noted that the index file is generally a binary file, and for convenience of description, the embodiments of the present application schematically show contents stored in the index file. In addition, the embodiment of the present application is exemplified by a code file and an index file based on a C language, and in other possible implementations, the code file and the index file may also be formed based on other programming languages, such as Java, Python, and the like.

Currently, the IDE mostly implements the indexing of code locally. Specifically, the language server in the IDE indexes the indexable objects of the entire program code file in full at the initial stage of program development, thus occupying a large amount of local system resources. IDE is also difficult to use for developing large programs if local system resources are low, which can even result in index failures. Moreover, when the program is cooperatively developed by multiple developers, each developer performs full-scale indexing, which increases time cost.

In order to solve the above problems, the present application provides a code index management method, in which an index service is decoupled from an IDE, that is, a full index is performed on a code submitted to a remote code repository at a remote end, all the IDEs can share the full index, a newly added developer can pull (pull) the code from the remote code repository through the IDE and obtain the full index from the remote end, thereby avoiding that a large amount of local system resources are occupied by creating the full index locally, enabling fewer local system resources to meet an index requirement, and improving an index success rate. Thus, lightweight IDEs can also be used to develop large programs. Further, the IDE locally performs incremental indexing when there are code changes locally.

Wherein, the full index refers to the creation of indexes for all submitted codes, and the incremental index refers to the creation of indexes for modified codes on the basis of the last version. The resource overhead of carrying out incremental indexing locally is far less than that of carrying out full indexing locally, so that the problem that a large amount of local system resources are occupied by the indexing service is solved. And when the program is cooperatively developed by multiple persons, each developer only carries out incremental indexing when the local code is changed, so that the indexing time is greatly reduced, and the indexing efficiency is improved.

The index management method provided by the application can be realized through a code index management system. Next, a system architecture of the code index management system provided in the present application will be described.

Referring to the system architecture diagram of the code index management system shown in FIG. 2, the code index management system includes at least one integrated development device 102, a remote code repository 104, and an indexing device 106 implementation. The program can be developed by cooperation of multiple persons or developed independently by a single person, and the application is exemplified by a scene of cooperation of multiple persons.

The integrated development device 102 includes a base development module 1022, a language services module 1024, a communications module 1026, and a storage module 1028. The basic development module 1022 is configured to provide basic functions of program development, including at least one of code editing, file reading, and code debugging. The language services module 1024 is used to provide programming language related functions, such as understanding the meaning of code expressions, such as understanding functions, variables, classes, or interfaces. The communication module 1026 is used to enable interaction with external devices. Where interaction with external devices may include interaction with remote code repository 104, indexing device 106. The storage module 1028 is for storing code. For code to be submitted or submitted, the storage module 1028 also stores a corresponding submission identification (commit ID). The commit identifier is used for distinguishing versions of the codes corresponding to different commit operations. The commit marker may be a hash value (commit hash) computed based on the code committed (or the code to be committed). The storage module 1028 further stores indexes of indexable objects included in the code, and the language service module 1024 provides functions such as syntax checking, lexical checking, auto-completion, function skip, variable skip, and the like based on the indexes.

A developer or project administrator in the program development project suite may create the remote code repository 104 via a versioning tool, such as Git, sub-version (SVN), etc. The remote code repository 104 includes a storage module 1042 and a hook module 1044 and a communication module 1046. The storage module 1042, among other things, can store code submitted from at least one member of the program development project group, including developers and project managers. The hook module 1044 can monitor for a set event. The hook module 1044 can generate a notification message upon the occurrence of the setup event. The communication module 1046 may send the notification message to the indexing device 106 to notify the setting event. The setting event may specifically be an event that submits code to the remote code repository 104.

The indexing device 106 comprises a communication module 1062, an index creation module 1064, an index management module 1066, and a storage module 1068. Among other things, the communication module 1062 is used to enable communication with external devices, such as the integrated development device 102 and/or the remote code repository 104. The index creation module 1064 is used to create a full-scale index based on the code submitted to the remote code repository 104. The index management module 1066 is used to manage the full-scale index created by the index creation module 1064. The storage module 1068 is used to store the code submitted to the remote code repository 104, the corresponding submission identification, and the full-scale index.

In particular implementations, a developer or project administrator (which may of course be another developer) who creates the remote code repository 104 may trigger a code submission operation in response to which the integrated development device 102 sends a code submission request to the remote code repository 104, the code submission request including the code and a corresponding submission identification (commit ID).

Correspondingly, hook module 1044 in remote code repository 104 monitors for the occurrence of an event that submits code to remote code repository 104, generates a notification message, and sends the notification message to indexing device 106 via communication module 1046. The communication module 1062 of the indexing device 106 is configured to obtain the submitted code and the corresponding submission identifier from the remote code repository 104 upon receiving the notification message from the remote code repository 104. The index creation module 1064 creates a full index from the acquired code. It should be noted that index creation module 106 may support multiprocess or multithreaded jobs that may create a full index for code submitted by developers or project administrators in multiple program development project groups. The storage module 1068 may store the code, commit identifier, and index.

Other developers in the program development project group or newly joining developers may trigger a code pull operation in response to which the communication module 1026 of the integrated development device 102 sends a code pull request to the remote code repository 104. The remote code repository 104 returns a code pull response to the integrated development device 102 that includes code submitted by a developer or project administrator in the program development project group and a corresponding submission identification.

The communication module 1026 of the integrated development device 102 is further configured to send an index obtaining request to the indexing device 106, and the communication module 1062 of the indexing device 106 returns an index corresponding to the code to the integrated development device 102 in response to the index obtaining request. The storage module 1028 of the integrated development device 102 stores the codes and the corresponding submission identifications and indexes, so that the language service module 1024 can provide at least one service of syntax checking, lexical checking, auto-completion, variable jumping, or function jumping based on the indexes.

After the developer pulls the code from the remote code repository, the developer may modify the pulled code through the base development module 1022, such as adding code to implement a new function or a new feature, modifying code to implement bug fixes, or deleting code to delete a function or a feature. For altered code, if the developer does not trigger an operation to be submitted to the remote code repository 104, the language services module 1024 may also create a delta index based on the altered code, and the storage module 1028 stores the delta index created by the language services module 1024. The incremental index is specifically an index that is additionally added relative to the full index that the integrated development device 102 obtains from the indexing device 106.

It should be noted that different developers may pull code at different times, while the code stored by the remote code repository 104 at different times may be different. Correspondingly, the full-scale indexes stored by the indexing device 106 at different times may be different. As such, the code that causes different developers to pull from the remote code repository 104 at different times may be different, and the full-scale index obtained from the indexing device 106 may be different. In addition, different developers may perform different changes to the code after pulling the code. For example, different developers may each develop a new function. Based on this, the delta index created by language services module 1024 for the altered code may be different.

In this case, the index stored by the integrated development device 102 corresponding to each developer that changes the code may be divided into two parts, one part is the full index obtained from the indexing device 106, and the other part is the incremental index created by the integrated development device 102. Therefore, the problem that the index success rate is influenced because the local full-scale indexing needs to be performed on each integrated development device 102 to occupy more local system resources is solved. Moreover, each integrated development device 102 directly obtains the full index from the indexing device 106 and performs incremental indexing when there is a code change locally, thus saving time consumed in indexing the code.

As described above, the integrated development device 102 is coupled with the code submission function and the code pull function, and in actual application, the code submission function and the code pull function may be decoupled from the integrated development device 102, and the code version control device 101 implements the code submission function and the code pull function. The code version control apparatus 101 in the present application may be a part of the integrated development apparatus 102 or may be a separate apparatus.

As shown in fig. 2, the code version control apparatus 101 includes a communication module 1012 and a storage module 1014. The memory module 1014 may store code, among other things. Further, the storage module 1014 may also store a commit identifier corresponding to the code. The communication module 1012 is configured to send a code submission request, including at least a code, to a remote code repository in response to a code submission operation. In some cases, a submission identifier corresponding to the code may also be included in the code submission request. In this way, the code version control apparatus 101 implements a code submission function, submits the code and its corresponding submission identifier to the remote code repository 104, and the integrated development apparatus 102 may acquire the code submitted by the code version control apparatus 101 and the corresponding submission identifier from the remote code repository 104 and then perform an index acquisition operation, thereby implementing index management.

The communication module 1012 may also send a code pull request to the remote code repository 104 in response to a code pull operation, and the communication module 1012 may then receive the code sent by the remote code repository 104 and, in some cases, the commit identifier for the code. The storage module 1014 stores the code and the corresponding commit identifier. Thus, the code version control device 101 realizes the code pulling function, and pulls the code and the corresponding submission identifier to the code version control device 101. The integrated development apparatus 102 may acquire the code and the corresponding commit identifier from the code version control apparatus 101 and then perform an index acquisition operation, thereby implementing index management.

It should be noted that, in the embodiment shown in fig. 2, the code version control apparatus 101 and the integrated development apparatus 102 are optional apparatuses of the code index management system, and in some possible implementations, the code index management system may implement code index management through the remote code repository 104 and the indexing apparatus 106.

For convenience of description, the integrated development device 102 is illustrated below as coupling a code submission function and a code pull function, and in other possible implementations of the embodiment of the present application, the code submission function and the code pull function may also be implemented by the code version control device 101 when performing code index management.

The code version control apparatus 101 may be deployed in a virtualized cloud device, or may be directly deployed in a physical device (PM). The integrated development device 102 may be deployed in a virtualized cloud appliance. The base development module 1022 and the language service module 1024 in the integrated development apparatus 102 may be two containers in the cloud device or two Virtual Machines (VMs). In some possible implementations, the integrated development device 102 may also be deployed directly in a physical device. Similarly, the remote code repository 104 may also be deployed in a cloud appliance. The storage module 1042, hook module 1044 of the remote code repository 104 may be containers or virtual machines in the cloud appliance. Of course, the remote code repository may also be deployed directly in the physical device. The indexing apparatus 106 may be deployed in a cloud device, and the index creation module 1064, the index management module 1066, and the storage module 1068 may be containers or virtual machines in the cloud device. Of course, the indexing device 106 may also be deployed directly in the physical device.

In consideration of data transmission resource overhead and transmission delay, the code version control apparatus 101 and the integrated development apparatus 102 may be deployed in the same device. Similarly, the remote code repository 104 and the indexing device 106 may be deployed in the same facility. Of course, the code version control apparatus 101, the integrated development apparatus 102, the remote code repository 104 and the indexing apparatus 106 may also be deployed in different devices, so that the robustness of the code index management system may be ensured.

Fig. 3 shows a possible application scenario of an embodiment of the present application. In this application scenario, the device 310, the device 320, and the device 330, the device 340 are all devices in the network. Where the device 310 is a user device, it may be, for example, a tablet computer, a personal computer, or the like. The device 320 is specifically a cloud device providing cloud services, and the device 320 may be virtualized by a cloud service provider for at least one device and provided externally in a unified form. The device 320 is disposed with the integrated development apparatus 102 for providing a program development environment. The device 330 is specifically a device providing an index service, which provides the index service by deploying the indexing apparatus 106. In particular implementations, the device 330 may be a server. A remote code repository 104 is deployed in the device 340 for providing code storage services. Device 340 and device 320 may each be cloud devices provided by a cloud service vendor.

Specifically, a developer may purchase a cloud service by accessing a web page through the device 310, a cloud service provider creates an instance of the integrated development device 320, that is, an IDE instance, in the device 320 according to a purchase result of the developer, and the developer may perform program development based on the IDE instance to obtain a code of the program. In developing a program, a developer or project administrator of a program development project group may trigger a code submission operation via an IDE instance, which may send a code submission request to the device 340 to submit the code in response to the code submission operation, and the device 330 may create a full index from the submitted code. Other developers of the program development project group may trigger a code pull operation through their corresponding IDE instances, which may send a code pull request to the device 340 to pull replacement codes from the device 340 in response to the code pull operation, and then the IDE instances may send an index get request to the device 330, the device 330 returning an index corresponding to the code to the IDE instances in response to the index get request, the IDE instances storing the index to provide programming language related services based on the index.

Further, when the developer also performs a change operation on the code, such as adding code, modifying code, and/or deleting code, through the IDE instance, and the developer has not triggered a code submission operation for the changed code, i.e., an operation to submit the changed code to the remote code repository 104, the IDE instance may also create a delta index based on the changed code and store the delta index.

Fig. 4 shows another possible application scenario of the embodiment of the present application. In this application scenario, the device 410, the device 420, and the device 430 are all devices in a network. Where the device 410 is a user device, it may be, for example, a tablet computer, a personal computer, or the like. The device 410 is deployed with the integrated development apparatus 102, the integrated development apparatus 102 may exist in the form of a software program, and the device 410 runs the integrated development apparatus 102 to generate an IDE instance, thereby providing a program development environment for developers. The developer develops the program based on the IDE instance and obtains the code of the program. The device 420 is specifically a device providing an index service, which provides the index service by deploying the indexing apparatus 106. In particular implementations, the device 420 may be a server. A remote code repository 104 is deployed in the device 430 for providing code storage services.

In the scenario illustrated in FIG. 4, a developer or project administrator of a program development project group may trigger a code submission operation via an IDE instance, which may send a code submission request to device 420 to submit code in response to the code submission operation, and device 430 may create a full index from the submitted code. Other developers of the program development project group may trigger a code pull operation through their corresponding IDE instances, which may send a code pull request to device 420 to pull a replacement code from device 420 in response to the code pull operation, and then the IDE instances may send an index get request to device 430, which device 430 returns an index corresponding to the code to the IDE instances in response to the index get request, which the IDE instances store to provide programming language related services based on the index.

Further, when the developer also performs a change operation on the code through the IDE instance, and the developer does not trigger an operation to submit the changed code to the remote code repository 104, the IDE instance may also create a delta index based on the changed code and store the delta index.

In order to make the technical solution of the present application clearer and easier to understand, the code index management method provided by the embodiment of the present application will be described below from the perspective of interaction between the integrated development device 102, the remote code repository 104 and the indexing device 106.

In the present application, a plurality of developers may be included in a program development project group. For convenience of description, in the embodiments of the present application, a developer who performs a code submission operation for the first time is referred to as a first developer, and a developer who pulls a code submitted by the first developer for development is referred to as a second developer.

Next, referring to a flowchart of a code index management method shown in fig. 5, the method includes:

the code version control device 101 sends a code submission request to the remote code repository 104 in response to a code submission operation triggered by the first developer S502.

Specifically, the code submission request includes the code and a corresponding submission identifier (commit ID). Wherein the commit identifier is used to distinguish between codes committed by different code commit operations. Based on this, the commit identification may be determined based on the code committed. In some possible implementations, the code may be hashed, and the hash value obtained by the hash calculation is used as the commit identifier. That is, the commit ID may be a hash value (commit hash) obtained by hashing the code.

The remote code repository 104 stores the code and the corresponding submission identification in response to the code submission request S504.

To implement versioning of the code, such as operating on a specified version of the code, etc., the remote code repository 104, when storing the code and the commit identifier, also stores the correspondence of the code and the commit identifier so that the developer can look up or obtain the corresponding code based on the commit identifier.

S506: indexing device 106 receives a notification message identifying the occurrence of an event that submitted a code to remote code repository 104, retrieves the code from remote code repository 104 and submits the identification.

Indexing device 106 may monitor for a set event by providing hook module 1044 within remote code repository 104, and when a set event occurs, hook module 1044 generates a notification message. Wherein the setup event may be an event that submits code to the remote code repository 104. In this way, when the code version control apparatus 101 performs a code submission operation, the remote code repository 104 may generate a notification message, the indexing apparatus 106 may receive the notification message, the notification message is used to identify that a developer (e.g., a first developer) submits a code to the remote code repository 104, and the indexing apparatus 106 may obtain the code submitted by the first developer through the code version control apparatus 101 and a corresponding submission identifier.

S508: indexing means 106 creates a full index from the submitted code.

In particular, indexing device 106 may identify indexable objects from the submitted code, i.e., identify identifiers in the submitted code. Upon identifying an indexable object, indexing device 106 can extract metadata for the indexable object, the metadata for the indexable object including a declaration and a location of the indexable object.

Wherein, the code comprises statements related to the indexable object, such as definition statements and/or declaration statements. Indexing means 106 determines the statements to which the indexable object relates based on the format of the statements to which the indexable object relates, such as the format of a define statement and/or a declarative statement, and indexing means 106 then determines the indexable object based on the statements.

Further, the indexing device 106 may determine the position of the indexable object based on the position of the statement in which the indexable object is located. The position of the indexable object can be characterized by the row number and the column number of the statement in which the indexable object is located. Indexing means 106 also determines a declaration of the indexable object based on a declaration statement in the statements related to the indexable object. In this manner, indexing device 106 may generate an index of an indexable object based on the metadata of the indexable object. Accordingly, indexing mechanism 106 generates an index for each indexable object in the submitted code, the index for the code including an index for each indexable object in the code.

It should be noted that the indexing device 106 creates an index for all code submitted to the remote code repository 104, which is a full index.

S510: indexing means 106 stores the code and the corresponding commit identifier and index.

When storing the code, submitting the identifier, and indexing, the indexing device 106 stores the correspondence between the code, the submitting identifier, and the indexing, so as to perform subsequent operations such as searching or obtaining based on the correspondence.

S512: the integrated development device 102 sends a code pull request to the remote code repository 104 in response to a code pull operation triggered by the second developer.

In a specific implementation, the second developer needs to acquire the code submitted by the first developer in order to develop the program based on the code. Specifically, the second developer may trigger a code pull (pull) operation by the integrated development device 102, in response to which the integrated development device 102 sends a code pull request to the remote code repository 104.

Wherein a second developer may access the remote code repository 104 through the integrated development device 102, the remote code repository 104 may expose code submitted by a first developer of at least one program development project group and a corresponding submission identification. Based on this, the second developer may trigger a code pull operation for the code submitted by the first developer that belongs to the same program development project group as the second developer, and the integrated development device 102 generates a code pull request according to the submission identifier corresponding to the code submitted by the first developer in response to the code pull operation, and sends the code pull request to the remote code repository 104.

S514: the remote code repository 104 sends the first developer submitted code and the corresponding submission identification to the integrated development device 102.

The remote code repository 104 determines the code requested by the integrated development device 102, i.e., the code submitted by the first developer, based on the code pull request, and in particular the submission identifier included in the code pull request. The remote code repository 104 then sends the code and corresponding submission identification to the integrated development device 102.

S516: the integrated development device 102 sends an index acquisition request to the indexing device 106.

The integrated development device 102 further sends an index obtaining request to the indexing device 106 to obtain a full index corresponding to the code submitted by the first developer from the indexing device 106. In particular implementations, a second developer may access indexing device 106 through integrated development device 102, and indexing device 106 may expose a full index created for code submitted by developers in different sets of program development projects.

Based on this, the second developer may trigger an index obtaining operation corresponding to the code submitted by the first developer for the program development project group, generate an index obtaining request according to the submission identifier corresponding to the code submitted by the first developer, and send the index obtaining request to the indexing device 106.

S518: the indexing device 106 sends the integrated development device 102 a full index of the code submitted by the first developer.

The remote code repository 104 determines the index requested by the integrated development device 102, i.e., the full index corresponding to the code submitted by the first developer, according to the submission identifier included in the index obtaining request. Then, the indexing device 106 sends the full index corresponding to the code to the integrated development device 102.

S520: the integrated development device 102 stores the code along with a corresponding commit identifier and a full index.

When the integrated development device 102 stores the code, the submission identifier, and the full index, the integrated development device also stores the corresponding relationship between the code, the submission identifier, and the full index, so as to perform operations such as querying or obtaining the code, the submission identifier, and the full index based on the corresponding relationship. In this way, when the developer develops a program based on the integrated development device 102, the integrated development device 102 can provide services related to a programming language, including syntax checking, lexical checking, auto completion, and jump services for functions, variables, and constants, based on the full index.

S522: the integrated development device 102 receives a change setting of the code by the second developer.

Further, after acquiring the code submitted by the first developer, the second developer may modify the code submitted by the first developer by using the integrated development device. For example, new code is added, code is modified or code is deleted, etc., based on the code submitted by the first developer. Correspondingly, the integrated development device 102 receives the change settings of the second developer to the code.

S524: the integrated development device 102 creates an incremental index from the altered code.

Specifically, the integrated development device 102 may create an index from the altered code before the altered code is submitted to the remote code repository 104, the index created by the integrated development device 102 being a delta index. The process of creating the index by the integrated development device 102 may refer to the description of the related content of S508, and is not described herein again.

It should be noted that the integrated development device 102 only needs to create an index for the changed code, and does not need to create an index for all codes, which reduces system resource occupation on the one hand, and saves the time spent on creating an index for all codes locally on the other hand.

S526: the integrated development device 102 stores the altered code and the delta index.

When storing the modified code and the incremental index, the integrated development device 102 may store a corresponding relationship between the modified code and the incremental index, so as to perform operations such as index lookup or index acquisition based on the corresponding relationship.

Further, when the modified code is submitted to remote code repository 104, hook module 1044 in remote code repository 104 may send a notification message to indexing device 106 notifying the occurrence of an event that submitted the code to remote code repository 104, and indexing device 106 may retrieve the submitted code and create a full index from all submitted codes.

It should be noted that the code index management method provided by the embodiment of the present application can be divided into three stages. In the first phase, indexing device 106 creates a corresponding full-scale index based on code submitted by a first developer. In the second phase, the integrated development device 102 obtains the full index corresponding to the code submitted by the first developer from the indexing device 106. In the third phase, the integrated development device 102 creates a delta index based on native code changes.

Based on the above description, the embodiment of the present application provides a code index management method, which supports a remote index device 106 to create a full index according to a code submitted to a remote code repository 104, so that when a developer pulls a code from the remote code repository 104 for program development, the developer can obtain the full index corresponding to the code from the index device 106, and does not need to create the full index locally, thereby solving the problem of occupying a large amount of local system resources, improving the index success rate, and enabling a lightweight IDE to be used for large program development. Furthermore, when the local codes are changed, the IDE can create the incremental index based on the changed codes, and the IDE can obtain the latest index without occupying a large amount of local system resources, so that the reliability of the index service is improved.

The developer may restart the IDE in consideration of possible interrupts during program development, such as interrupts caused by other transactions of the developer or exceptions occurring during the current program development project. Based on this, the IDE may refresh the index stored in the IDE according to the full amount of indexes stored by the indexing device 106. In addition, when the language service generates an error, the IDE may also refresh the index stored in the IDE according to the full index stored by the indexing device 106. The developer may also configure a refresh cycle by which the IDE may refresh the index stored in the IDE based on the full amount of indexes stored by indexing device 106.

For ease of understanding, the code index management method provided in the embodiment of the present application is described below with reference to the index refresh process of the integrated development device 102 in the embodiment shown in fig. 5.

Referring to a flowchart of a code index management method shown in fig. 6, the method includes:

s602: the integrated development device 102 sends a submit-identification query request to the indexing device 106.

The submit identification query request is for requesting a query for the submit identification most recently submitted to remote code repository 104. In particular implementations, the submitted identification query request may include an identification list of submitted identifications stored by the integrated development device 102. The submission identifiers in the identifier list may be sorted according to the submission time, for example, the submission identifiers may be filled into the form in the order from the last submission time to the first submission time to form the identifier list.

After receiving the change setting of the code by the developer, the integrated development device 102 may further perform hash calculation on the changed code to obtain a hash value as a submission identifier, so as to distinguish the codes submitted at different times. I.e. the commit ID, may specifically be a hash value (commit hash) determined on the basis of the altered code.

Based on this, the commit markers stored by the integrated development device 102 may include not only the commit markers submitted to the remote code repository 104, but also the commit markers not submitted to the remote code repository 104. Wherein the commit markers not committed to the remote code repository 104 may include at least one of a commit marker committed to the local code repository or a commit marker determined when code is added to the staging area.

Further, when the number of the submitted identifiers stored in the integrated development device 102 is multiple, the integrated development device 102 may generate multiple identifier lists according to the multiple identifiers, and sequentially send the identifier lists in a multiple sending manner, in consideration of data transmission overhead. When the indexing device 104 determines the identity of the most recent submission to the remote code repository 104, the integrated switch device 102 may stop sending the list of identities. This approach may significantly reduce the resource overhead of transmitting the identity list compared to transmitting the identity list comprising all identities at once.

It should be noted that, in order to improve the query efficiency, the integration unlocking apparatus 102 may further increase the number of submitted identifiers included in the identifier list sent this time on the basis that the identifier list sent last time includes the number of submitted identifiers when the identifier list is sent. For example, the number of identifiers included in the identifier list transmitted this time may be twice as many as the number of identifiers included in the identifier list transmitted last time.

S604: indexing device 106 queries the submission identification of the most recent submission to remote code repository 104.

Indexing device 106 stores submission identifications of all developers submitted to the remote code repository. The intersection of the submission identifier stored by the indexing device 106 and the submission identifier stored by the integrated development device 102 is the submission identifier submitted to the remote code repository 104 by the second developer corresponding to the integrated development device 102. Indexing device 106 selects the commit marker with the most recent commit time from the intersection and obtains the commit marker that was most recently committed to remote code repository 104.

In a specific implementation, the identifier lists sent by the integrated development device 102 are sorted sequentially from the last to the first according to the submission time, and the indexing device 106 may sequentially query whether the submission identifiers included in the identifier lists sent by the integrated development device 102 exist in the indexing device 106, and if so, determine that the submission identifiers are the latest submission identifiers submitted to the remote code repository 104. If not, then indexing device 106 may instruct integrated development device 102 to continue sending the list of identifications, and then indexing device 106 may continue performing the query operations described above until a commit identification is determined that was most recently committed to remote code repository 104.

For ease of understanding, the description is made in conjunction with specific examples. In one example, the integrated development device 102 stores 1000 commit hashes, and the 1000 commit hashes are numbered 0 to 999 sequentially from time to time. The integrated development device 102 may first send 100 commit hashes numbered 0 to 99 to the indexing device 106, and the indexing device 106 sequentially inquires whether the 100 commit hashes exist in the hash list on the indexing device 106 side. If so, the determined commit hash that was first present in the hash list on the indexing device 106 side is determined to be the commit hash most recently submitted to the remote code repository 104. If not, the integrated development device 102 sends 200 commit hashes numbered from 100 to 299, and the indexing device 106 inquires whether the 200 commit hashes exist in the hash list on the indexing device 106 side. And so on, and will not be described in detail herein.

S606: the indexing device 106 sends the integrated development device 102 an identification of the latest submission to the remote code repository 104.

S608: the integrated development device 102 determines whether the integrated development device 102 stores a corresponding index based on the last submitted identification submitted to the remote code repository 104 and the previous submitted identification.

When the submission identifier newly submitted to the remote code repository 104 and the index corresponding to the previous submission identifier are not stored in the integrated development device 102, the index that is not stored is referred to as a target index for convenience of description.

S610: the integrated development device 102 sends an index acquisition request to the indexing device 106.

The index obtaining request is used to request to obtain the target index determined by S608. The target index is an index that corresponds to the last commit marker submitted to the remote code repository 104 and the previous commit markers and is not stored in the integrated development device 102.

S612: the indexing device 106 sends the target index to the integrated development device 102 in response to the index acquisition request.

Indexing device 106 queries the full index based on the last submission identifier submitted to remote code repository 104 and the previous submission identifiers, and obtains the target index from the full index. The target index is then sent to the integrated development device 102.

S614: the integrated development device 102 stores the target index.

Specifically, the integrated development device 102 may store the target index in an index cache (index cache), so as to implement refreshing the index in the integrated development device 102. For ease of understanding, this application also provides a specific example for illustration.

As shown in fig. 7, it shows an identification list formed by the integrated development apparatus 102 and the commit identifications stored on the indexing apparatus 106 side. Indexing device 106 determines the commit identifier that was most recently committed to remote code repository 104 by comparing the integrated development device 102 side identifier list with the indexing device 106 side identifier list. In this example, the submission identification of the most recent submission to the remote code repository 104 may be 3bd1323 f.

In the identification list on the integrated development device 102 side, an identification above the commit identification newly submitted to the remote code repository 104, such as d331c1fd, is a commit identification for which a remote commit operation is not performed. In the list of identifications on the indexing device 106 side, the identification above the last submitted identification to the remote code repository 104, e.g., 345bd321, is the submitted identification submitted to the remote code repository 104 by other developers.

The integrated development device 102 queries whether the integrated development device 102 side stores a corresponding index according to the submission identifier newly submitted to the remote code repository 104 and the previous submission identifier in the identifier list of the integrated development device 102 side, and if not, acquires the corresponding index from the full-scale indexes stored in the indexing device 106 according to the submission identifier and stores the corresponding index in the index cache to refresh the index of the integrated development device 102.

In some possible implementations, if the identification list on the integrated development device 102 side is empty, the integrated development device 102 may not perform the above S602 to S608, and directly obtain the full index from the indexing device 106 side. In other possible implementations, if the integrated development device 102 does not have the commit identifier submitted to the remote code repository 104, the integrated development device 102 may not perform the above S610 to S614.

The code index management method provided by the present application is described above with reference to fig. 1 to 7, and the related apparatuses and devices provided by the present application will be described next with reference to the accompanying drawings.

Referring to the schematic structural diagram of the indexing device 106 shown in fig. 2, the indexing device 106 includes:

a communications module 1062 for obtaining the code from the remote code repository 104;

an index creation module 1064 for creating a full index of the code from the code;

a storage module 1068, configured to store a full index of the code;

the communication module 1062 is further configured to send the full amount of code to the integrated development device 102.

In some possible implementations, the index creation module 1064 is specifically configured to:

In some possible implementations, the remote code repository 104 further stores a submission identifier of the code, and the storage module 1068 further stores a correspondence between the submission identifier of the code and the full index of the code;

the communication module 1062 is further configured to:

receiving an index acquisition request from the integrated development device 102, wherein the index acquisition request comprises a submission identifier of the code;

and sending the full index of the code to the integrated development device 102 according to the submission identification of the code.

In some possible implementations, the apparatus 106 further includes an index management module 1066;

the communication module 1062 is further configured to receive a submitted identifier query request from the integrated development device, where the submitted identifier query request includes an identifier list formed by submitted identifiers stored in the integrated development device;

the index management module 1066 is configured to determine, according to the identifier list, a latest submission identifier submitted to the remote code repository;

the communication module 1062 is further configured to return the latest submission identifier submitted to the remote code repository to the integrated development device, so that the integrated development device obtains a target index according to the latest submission identifier submitted to the remote code repository, where the target index is an index corresponding to a code submitted to the remote code repository by the integrated development device and is not stored by the integrated development device.

the index management module 1066 is specifically configured to:

Next, referring to a schematic structural diagram of an integrated development device 102 shown in fig. 2, the integrated development device 102 includes:

a communication module 1026 configured to receive the code transmitted by the remote code repository 104 and to receive a full index of the code transmitted by the indexing device 106;

a storage module 1028 for storing the code and a full index with the code.

In some possible implementations, the remote code repository 104 further stores a submission identifier of the code, and the indexing device 106 further stores a correspondence between the submission identifier of the code and the full-scale index of the code;

the communication module 1026 is further configured to:

sending an index obtaining request to the indexing device 106, where the index obtaining request includes the submission identifier of the code, so that the indexing device 106 sends the full index of the code according to the submission identifier of the code.

In some possible implementations, the apparatus 102 further includes:

a basic development module 1022, configured to receive, by the integrated development apparatus, a change setting for the code, and obtain a changed code;

a language service module 1024, configured to create an increment index according to the changed code and store the changed code and the increment index corresponding to the changed code before submitting the changed code to the remote code repository.

In some possible implementations, the communication module 1026 is further configured to:

The index device 106 and the integrated development device 102 according to the embodiment of the present application may correspond to performing the method described in the embodiment of the present application, and the above and other operations and/or functions of each module in the integrated development device 102 and the index device 106 are respectively for implementing corresponding flows of each method in fig. 5 to fig. 6, and are not described herein again for brevity.

Fig. 8-9 also provide an apparatus. The apparatus 800 shown in fig. 8 may be specifically configured to implement the functions of the indexing device 106 in the embodiment shown in fig. 2, and the apparatus 900 shown in fig. 9 may be specifically configured to implement the functions of the integrated development device 102 in the embodiment shown in fig. 2.

The device 800 includes a bus 801, a processor 802, a communication interface 803, and a memory 804. The processor 802, memory 804, and communication interface 803 communicate over a bus 801. The bus 801 may be a Peripheral Component Interconnect (PCI) bus, an Extended Industry Standard Architecture (EISA) bus, or the like. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is shown in FIG. 8, but this is not intended to represent only one bus or type of bus. The communication interface 803 is used to communicate with the outside world, such as to receive notification messages identifying the occurrence of an event that submitted a code to the remote code repository 104, to retrieve a code from the remote code repository 104, and so forth.

The processor 802 may be a Central Processing Unit (CPU). The memory 804 may include volatile memory (volatile memory), such as Random Access Memory (RAM). The memory 804 may also include a non-volatile memory (non-volatile memory), such as a read-only memory (ROM), a flash memory, an HDD, or an SSD.

The memory 804 stores executable code that the processor 802 executes to perform the code index management methods described above.

Specifically, in the case of implementing the embodiment shown in fig. 2, and in the case of implementing the modules described in the embodiment of fig. 2 by software, software or program codes required for performing the functions of the index creation module 1064 and the index management module 1066 in fig. 2 are stored in the memory 804. The storage module 1068 may be a block of storage space in the memory 804 in which the code and the corresponding commit identifier and full index are stored. The communication module 1062 functions are implemented by the communication interface 803. The processor 802 is configured to execute instructions in the memory 804 to perform a code index management method applied to the index device 106.

Device 900 includes a bus 901, a processor 902, a communication interface 903, and a memory 904. The processor 902, memory 904, and communication interface 903 communicate over a bus 901. In the case of the apparatus 900 implementing the embodiment shown in fig. 2 and the modules described in the embodiment of fig. 2 being implemented by software, software or program codes required for performing the functions of the basic development module 1022 and the language service module 1024 in fig. 2 are stored in the memory 904. The storage module 1028 may be a block of storage space in the memory 904 where the code and the corresponding commit markers and full, delta indices are stored. The communication module 1026 functions are implemented by the communication interface 903. The processor 902 is configured to execute the instructions in the memory 904 to perform the code index management method applied to the integrated development device 102.

Embodiments of the present application further provide a computer-readable storage medium, which includes instructions that, when executed on a computer, cause the computer to execute the code index management resolving method applied to the index device 106.

Embodiments of the present application also provide a computer-readable storage medium, which includes instructions that, when executed on a computer, cause the computer to execute the code index management method applied to the integrated development device 102.

The embodiment of the application also provides a computer program product, and when the computer program product is executed by a computer, the computer executes any one of the code index management methods. The computer program product may be a software installation package that can be downloaded and executed on a computer in the event that any of the aforementioned code index management methods are required.

It should be noted that the above-described embodiments of the apparatus are merely schematic, where the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. In addition, in the drawings of the embodiments of the apparatus provided in the present application, the connection relationship between the modules indicates that there is a communication connection therebetween, and may be implemented as one or more communication buses or signal lines.

Through the above description of the embodiments, those skilled in the art will clearly understand that the present application can be implemented by software plus necessary general-purpose hardware, and certainly can also be implemented by special-purpose hardware including special-purpose integrated circuits, special-purpose CPUs, special-purpose memories, special-purpose components and the like. Generally, functions performed by computer programs can be easily implemented by corresponding hardware, and specific hardware structures for implementing the same functions may be various, such as analog circuits, digital circuits, or dedicated circuits. However, for the present application, the implementation of a software program is more preferable. Based on such understanding, the technical solutions of the present application may be substantially embodied in the form of a software product, which is stored in a readable storage medium, such as a floppy disk, a usb disk, a removable hard disk, a ROM, a RAM, a magnetic disk, or an optical disk of a computer, and includes several instructions for enabling a computer device (which may be a personal computer, an exercise device, or a network device) to execute the method according to the embodiments of the present application.

In the above embodiments, the implementation may be wholly or partially realized by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product.

The computer program product includes one or more computer instructions. When loaded and executed on a computer, cause the processes or functions described in accordance with the embodiments of the application to occur, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. The computer instructions may be stored in a computer readable storage medium or transmitted from one computer readable storage medium to another, for example, from one website site, computer, training device, or data center to another website site, computer, training device, or data center via wired (e.g., coaxial cable, fiber optic, Digital Subscriber Line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that a computer can store or a data storage device, such as a training device, a data center, etc., that incorporates one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., Solid State Disk (SSD)), among others.

Claims

1. A code index management method, comprising:

the remote code warehouse receives the codes submitted by the code version control device;

the indexing means obtaining the code from the remote code repository;

the indexing device creates a full index of the code according to the code and stores the full index of the code;

the remote code repository sending the code to an integrated development device;

the indexing device sends a full index of the code to the integrated development device.

2. The method of claim 1, wherein the indexing device creates a full index of the code before the integrated development device receives the code.

3. The method according to claim 1 or 2, wherein the remote code repository further stores a submission identifier of the code, and the indexing device further stores a correspondence between the submission identifier of the code and the full index of the code;

the remote code repository sending the code to an integrated development device, comprising:

the remote code repository sends the code and a submission identifier of the code to an integrated development device;

the method further comprises the following steps:

the integrated development device sends an index acquisition request to the indexing device, wherein the index acquisition request comprises the submission identification of the code;

the indexing device sends the full-scale index of the code to the integrated development device, and comprises:

and the indexing device sends the full index of the code to the integrated development device according to the submission identification of the code.

4. The method according to any one of claims 1 to 3, further comprising:

before submitting the altered code to the remote code repository, the integrated development device creates a delta index from the altered code, stores the altered code and the delta index corresponding to the altered code.

5. The method of claim 3, further comprising:

the index device determines a submission identifier submitted to the remote code warehouse latest according to the identifier list, and returns the submission identifier submitted to the remote code warehouse latest to the integrated development device;

6. A code index management method, the method comprising:

after the remote code warehouse receives the submitted codes, the indexing device acquires the codes from the remote code warehouse;

the index device receives an index acquisition request sent by an integrated development device, wherein the index acquisition request is used for acquiring a full index of the code;

and the indexing device sends the full index of the codes to the integrated development device according to the index acquisition request.

7. The method of claim 6, wherein the indexing device creates a full index of the code before the integrated development device sends the index acquisition request.

8. The method according to claim 6 or 7, characterized in that the method further comprises:

the index device returns the latest submission identifier submitted to the remote code warehouse to the integrated development device, so that the integrated development device obtains a target index according to the latest submission identifier submitted to the remote code warehouse, wherein the target index is an index corresponding to a code submitted to the remote code warehouse by the integrated development device and is not stored by the integrated development device.

9. A code index management method, the method comprising:

the integrated development device acquires codes stored in a remote code warehouse and submission identifications of the codes;

the integrated development device sends an index acquisition request to an indexing device, wherein the index acquisition request comprises a submission identifier of the code, and the indexing device stores the corresponding relation between the full index of the code and the submission identifier of the code;

and the integrated development device receives the full index of the code determined by the indexing device according to the submission identification of the code.

10. The method of claim 9, further comprising:

11. The method according to claim 9 or 10, characterized in that the method further comprises:

12. A code index management system, characterized in that the code index management system comprises:

13. The code index management system of claim 12, wherein the indexing means is specifically configured to:

14. The code index management system according to claim 12 or 13, wherein the remote code repository further stores a submission identifier of the code, and the indexing device further stores a correspondence between the submission identifier of the code and the full index of the code;

the remote code repository is specifically configured to:

the code index management system further includes:

the indexing means is specifically configured to:

15. The code index management system according to any one of claims 12 to 14, wherein the integrated development device is further configured to:

receiving the change setting of the code to obtain a changed code;

creating a delta index from the altered code before the altered code is submitted to the remote code repository, storing the altered code and the delta index corresponding to the altered code.

16. The code index management system of claim 14, wherein the integrated development device is further configured to:

17. An indexing device, characterized in that the indexing device comprises:

a communication module for obtaining a code from a remote code repository;

the storage module is used for storing the full index of the code;

18. The apparatus of claim 17, wherein the index creation module is specifically configured to:

19. The apparatus according to claim 17 or 18, wherein the remote code repository further stores a submission identifier of the code, and the storage module further stores a correspondence between the submission identifier of the code and the full index of the code;

the communication module is further configured to:

20. The apparatus of claim 19, further comprising an index management module;

21. An integrated development apparatus, the apparatus comprising:

22. The apparatus of claim 21, wherein the remote code repository further stores a commit identifier of the code, and wherein the indexing means further stores a correspondence between the commit identifier of the code and a full index of the code;

the communication module is further configured to:

23. The apparatus of claim 21 or 22, further comprising:

the basic development module is used for receiving the change setting of the code and obtaining the changed code;

24. The apparatus of claim 22, wherein the communication module is further configured to:

25. An apparatus, comprising a processor and a memory;

the processor is configured to execute instructions stored in the memory to perform the code index management method of any of claims 6 to 8.

26. An apparatus, comprising a processor and a memory;

the processor is configured to execute instructions stored in the memory to perform the code index management method of any of claims 9 to 11.

27. A computer-readable storage medium comprising instructions that, when executed on a device, cause the device to perform the code index management method of any one of claims 6 to 8.

28. A computer-readable storage medium comprising instructions that, when executed on a device, cause the device to perform the code index management method of any of claims 9 to 11.