CN117806739A - Determine methods, devices, media and equipment for calling relationships across code repositories - Google Patents

Abstract

The present disclosure relates to a method, apparatus, medium and device for determining a call relationship across code repositories. The method comprises: determining a first call relationship between functions contained in at least two code repositories and functions in the code repositories; for a target function in the code repositories that has a remote call behavior, determining a target service identifier and a target interface identifier for the remote call of the target function; determining a target routing function for the remote call of the target function across code repositories based on the target service identifier, the target interface identifier and the target mapping relationship, and forming a second call relationship between the target function and the target routing function, wherein the target mapping relationship is used to indicate a mapping relationship between a code repositories and a service; generating a function call relationship between functions contained in the at least two code repositories based on the first call relationship and the second call relationship.

Description

Determine methods, devices, media and equipment for calling relationships across code repositories

Technical field

The present disclosure relates to the field of computer technology, and in particular, to a method, apparatus, medium and device for determining a calling relationship across code repositories.

Background technique

With the development of digital technology, more and more workflows and services are built on software systems, causing software systems to become increasingly complex, and microservice technology emerged as the times require. In the microservice architecture, the overall service is split into modular independent services. Each service has an independent code warehouse. Services are communicated through interfaces and RPC (Remote Procedure Call) calls. Interaction. However, with the explosive growth of the number of microservices and components, the structures between services in the service layer and between components in the code layer are becoming more and more complex. There are often multi-level dependencies and multi-level data transfer, resulting in The relationship between services is becoming increasingly difficult to clarify.

Contents of the invention

This summary is provided to introduce concepts in a brief form that will be described in detail in the detailed description below. This summary is not intended to identify key features or essential features of the claimed technical solution, nor is it intended to limit the scope of the claimed technical solution.

In a first aspect, the present disclosure provides a method for determining a calling relationship across code repositories. The method includes:

Determine the first calling relationship between functions contained in at least two code repositories and functions in the code repositories;

For the target function with remote calling behavior in the code warehouse, determine the target service identifier and target interface identifier of the remote call of the target function;

According to the target service identifier, the target interface identifier and the target mapping relationship, determine the target routing function that the target function remotely calls across the code repository, and form a second calling relationship between the target function and the target routing function, wherein the target mapping relationship is used to indicate a mapping relationship between a code repository and a service;

According to the first calling relationship and the second calling relationship, a function calling relationship between functions included in the at least two code repositories is generated.

In a second aspect, the present disclosure provides a device for determining a call relationship across code repositories, the device comprising:

A first determining module, configured to determine a first calling relationship between functions included in at least two code repositories and functions in the code repositories;

The second determination module is used to determine the target service identifier and target interface identifier of the remote call of the target function for the target function in the code warehouse that has remote calling behavior;

The third determination module is used to determine the target routing function that the target function calls remotely across the code warehouse according to the target service identifier, the target interface identifier and the target mapping relationship, and form the target function and the target route The second calling relationship between functions, wherein the target mapping relationship is used to indicate the mapping relationship between the code warehouse and the service;

The first generating module is used to generate a function calling relationship between functions included in the at least two code repositories according to the first calling relationship and the second calling relationship.

In a third aspect, the present disclosure provides a computer-readable medium having a computer program stored thereon, and when the program is executed by a processing device, the steps of the method described in the first aspect of the present disclosure are implemented.

In a fourth aspect, the present disclosure provides an electronic device, including:

a storage device having a computer program stored thereon;

A processing device, configured to execute the computer program in the storage device to implement the steps of the method described in the first aspect of the present disclosure.

Through the above technical solution, the first calling relationship between the functions contained in at least two code warehouses and the functions in the code warehouse is determined. For the target function with remote calling behavior in the code warehouse, the target service identifier and target of the remote calling of the target function are determined. Interface identification, based on the target service identification, target interface identification and target mapping relationship, determine the target routing function that the target function calls remotely across the code warehouse, and form a second calling relationship between the target function and the target routing function, and then based on the first call The relationship and the second calling relationship generate the function calling relationship between functions in the code warehouse. Therefore, by constructing the mapping relationship between the code warehouse and the service, the corresponding code warehouse can be determined according to the remotely called service, and then the routing function that provides the remote calling interface can be clearly located, forming a remote calling relationship between functions. , that is, the function calling relationship across code warehouses. In this way, even in scenarios where data is called across warehouses, a clear calling relationship between functions can still be formed, which is conducive to the discovery of security risks and the confirmation of data transfer between services based on this calling relationship.

Other features and advantages of the present disclosure will be described in detail in the detailed description that follows.

Description of drawings

The above and other features, advantages, and aspects of various embodiments of the present disclosure will become more apparent with reference to the following detailed description taken in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numbers refer to the same or similar elements. It is to be understood that the drawings are schematic and that elements and elements are not necessarily drawn to scale. In the attached picture:

Figure 1 is a flow chart of a method for determining a calling relationship across code repositories according to an embodiment of the present disclosure;

FIG2 is an exemplary function call graph in the method for determining a call relationship across code repositories provided by the present disclosure;

Figure 3 is an exemplary function call diagram before modification in the cross-code repository calling relationship determination method provided by the present disclosure;

FIG4 is an exemplary modified function call graph in the method for determining a calling relationship across code repositories provided by the present disclosure;

FIG5 is a schematic diagram of an exemplary overall process of a method for determining a calling relationship across code repositories provided by the present disclosure;

Figure 6 is a block diagram of a cross-code repository calling relationship determination device provided by an embodiment of the present disclosure;

FIG. 7 shows a schematic structural diagram of an electronic device suitable for implementing embodiments of the present disclosure.

Detailed ways

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the disclosure are shown in the drawings, it should be understood that the disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, which rather are provided for A more thorough and complete understanding of this disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of the present disclosure.

It should be understood that various steps described in the method implementations of the present disclosure may be executed in different orders and/or in parallel. Furthermore, method embodiments may include additional steps and/or omit performance of illustrated steps. The scope of the present disclosure is not limited in this regard.

The term "including" and its variations used herein are open inclusions, i.e., "including but not limited to". The term "based on" means "based at least in part on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". The relevant definitions of other terms will be given in the following description.

It should be noted that concepts such as “first” and “second” mentioned in this disclosure are only used to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units. Or interdependence.

It should be noted that the modifications of "one" and "plurality" mentioned in this disclosure are illustrative and not restrictive. Those skilled in the art will understand that unless the context clearly indicates otherwise, it should be understood as "one or Multiple”.

The names of messages or information exchanged between multiple devices in the embodiments of the present disclosure are for illustrative purposes only and are not used to limit the scope of these messages or information.

It can be understood that before using the technical solutions disclosed in the embodiments of this disclosure, users should be informed of the type, scope of use, usage scenarios, etc. of the personal information involved in this disclosure in an appropriate manner in accordance with relevant laws and regulations and obtain the user's authorization. .

For example, in response to receiving an active request from a user, a prompt message is sent to the user to clearly remind the user that the operation requested will require the acquisition and use of the user's personal information. Therefore, users can autonomously choose whether to provide personal information to software or hardware such as electronic devices, applications, servers, or storage media that perform operations of the technical solution of the present disclosure based on the prompt information.

As an optional but non-limiting implementation method, in response to receiving the user's active request, the method of sending prompt information to the user may be, for example, a pop-up window, and the prompt information may be presented in the form of text in the pop-up window. In addition, the pop-up window can also contain a selection control for the user to choose "agree" or "disagree" to provide personal information to the electronic device.

It can be understood that the above process of notifying and obtaining user authorization is only illustrative and does not limit the implementation of the present disclosure. Other methods that satisfy relevant laws and regulations can also be applied to the implementation of the present disclosure.

At the same time, it can be understood that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) should comply with the requirements of corresponding laws, regulations and relevant regulations.

As mentioned in the background art, as the number of microservices and components increases, the structure between services becomes more and more complex, resulting in unclear relationships. In related technologies, in order to solve this problem, the method of inserting probe code into each service is often used to monitor runtime data. However, this method requires inserting code into each service, which has high implementation costs and requires additional Consider the performance and computing overhead of the service.

In addition, code analysis can also be used to analyze the calling relationship between functions. However, current code analysis can often only focus on a single code warehouse, that is, it can only analyze the function calling relationship between a single language and a single warehouse. The application scenario is relatively simple. For example, a SQL (Structured Query Language, Structured Query Language) injection vulnerability. The warehouse of service A is a package service of the MySQL database, and the warehouse of service B is business code. Due to performance and complexity of SQL statements, service A does not have SQL injection. Defense capabilities, this requires analyzing whether the upper-layer code of service A has implemented corresponding defenses. This may involve multi-level dependencies and data transfer processes, as well as code warehouses in multiple development languages. The calling relationship between functions remains Hard to pinpoint.

The functions involved in this disclosure are functions defined in computer technology. In computer technology, a function is a mechanism that encapsulates a reusable block of code that performs a specific operation or completes a specific task. Functions can accept parameters as input, implement specific functions through code execution, and return a value as output. Functions can provide a composable, reusable and modular code structure to facilitate code maintenance and expansion. Unlike functions in mathematical concepts, functions in code are an abstract concept provided by a programming language for organizing and managing code.

In order to solve the above technical problems, the present disclosure provides a method, device, medium and equipment for determining a calling relationship across code warehouses.

FIG. 1 is a flow chart of a method for determining a calling relationship across code repositories according to an embodiment of the present disclosure.

In general, the code follows the following business data flow model:

A service corresponds to a code warehouse, which contains one or more modules at the language level, including business code and dependent modules;

Each service (code warehouse) provides multiple interfaces to the outside world. Different interfaces will register different entry functions with the framework. The entry functions receive request data from users or request data from other services;

After the entry function obtains the requested data, it processes the data according to different business processing functions, such as calling database operation functions to add, delete, modify, and query data. In a single warehouse, data flows during the calling process of the function;

When calling across services (i.e., calling across code repositories), the S1 service needs to provide a special function call (i.e., remote call) to the framework client. The framework communicates with the framework of the S2 service through the target address (i.e., microservice ID) and interface name. The framework of the S2 service sends the data to the entry function of the corresponding interface for processing, obtains the processing result and returns it to S1. Between repositories, data flows during the remote call process. Generally speaking, the calling function provided by the framework client is directly connected to the entry function registered with the framework server.

Based on the above flow model, the skeleton of data flow can be initially constructed. This skeleton usually contains the following data elements:

Node: a repository node that represents a code repository. A code repository can use the repository name as the unique identifier of the repository. A function node that represents a function defined by the code. A function can use the function name as the unique identifier of the function.

Relationship: the service provision relationship between warehouse nodes and function nodes; the calling relationship between functions in the warehouse; the remote calling relationship between different functions in different warehouses.

As shown in Figure 1, the method provided by the present disclosure may include steps 11 to 14.

In step 11, a first calling relationship between functions contained in at least two code warehouses and functions in the code warehouses is determined.

As mentioned above, the present disclosure involves data calling scenarios across code repositories. Therefore, the code repositories involved in the present disclosure include at least two, and there is remote calling behavior between the at least two code repositories. In actual application scenarios, multiple code warehouses are usually involved, and the function calling relationships in these code warehouses need to be determined. Optionally, step 11 can perform the above analysis and determination on all involved code repositories.

For each code repository, static analysis can be used to determine the calling relationship between the functions contained in the code repository and the functions in the code repository, that is, the first calling relationship. The first calling relationship is the calling relationship between functions within a code repository.

In addition, static analysis can also be used to determine the external interfaces provided by the code warehouse (for example, they can be distinguished by interface identifiers), the services and interfaces remotely called by the code warehouse, and the methods used in the code warehouse to remotely call the above services and interfaces. functions etc.

For example, the above static analysis can be implemented using RTA (Rapid Type Analysis, rapid type analysis) analysis algorithm or VTA (Value-Flow Type Analysis, value flow type analysis).

In step 12, for the target function with remote calling behavior in the code warehouse, determine the target service ID and target interface ID of the target function for remote calling.

As mentioned above, static code analysis can be used to determine the services and interfaces that are remotely called by the code repository, and it can also be used to determine which function in the code repository implements the remote call, thereby easily determining the target function that has the remote call behavior.

At the same time, in the present disclosure, the service can be represented by a service identifier (such as a service name), and the interface can be represented by an interface identifier (such as an interface name). Based on this, it is easy to determine the service identifier and interface identifier of the service remotely called by the target function, and thus obtain the target service identifier and target interface identifier.

In step 13, based on the target service identifier, the target interface identifier and the target mapping relationship, the target routing function that the target function calls remotely across the code warehouse is determined, and a second calling relationship between the target function and the target routing function is formed.

Among them, the target mapping relationship can be used to indicate the mapping relationship between the code warehouse and the service.

Since the client can only obtain the service and information related to the service, the code and functions of the service cannot be known, which can only be obtained on the server through the code repository corresponding to the service. Therefore, the service and the code repository can be associated by establishing the above target mapping relationship, so that the code repository providing the service can be determined through the service, and the relevant information in the code repository can be clarified.

Optionally, the target mapping relationship can be determined by:

Determine the correspondence between the service identifier of the service and the interface identifier of the service;

Determine the correspondence between the warehouse ID of the code warehouse and the interface ID of the code warehouse;

Generate a target mapping relationship based on the service ID and warehouse ID associated with the same interface ID.

For example, the microservice call information can be extracted while obtaining the remote call related information, and then a tuple of the correspondence between the service identifier (for example, service ID) and the service's interface identifier (for example, interface name) can be constructed. .

For example, during the above static code analysis process, the external interface of the code warehouse can be extracted, and a binary corresponding relationship between the warehouse identification (for example, warehouse name) and the interface identification (for example, interface name) of the code warehouse can be formed. Group. At this time, the function corresponding to the interface (ie, the entry function) can also be learned through static code analysis.

Based on this, through the same interface identifier (for example, an interface with the same name), a corresponding relationship can be established between the service identifier and the warehouse identifier, thereby forming a target mapping relationship between the service and the code warehouse.

In a possible implementation, step 13 may include the following steps:

According to the target mapping relationship, determine the target code warehouse corresponding to the target service identifier;

Determine the function in the target code warehouse where the interface corresponding to the target interface identifier is located as the target routing function, and form a second calling relationship between the target function and the target routing function. The target routing function is essentially a function in other code repositories that is remotely called by the target function.

According to the target service identifier of the service remotely called by the target function, the corresponding code warehouse can be determined through the above target mapping relationship as the target code warehouse. Since the target code repository is the code used to provide the service, the called interfaces are consistent. Based on this, the corresponding interface can be located in the target code repository according to the target interface identifier, and then the location of the interface can be determined. function, the routing function called remotely by the target function is determined, that is, the target routing function. Thus, a second calling relationship between the target function and the target routing function can be formed. The second calling relationship is the remote calling relationship between different functions in different code warehouses.

In step 14, a function calling relationship between functions included in at least two code repositories is generated according to the first calling relationship and the second calling relationship.

The first calling relationship can represent the function calling relationship within the warehouse in the code warehouse involved in the present disclosure, and the second calling relationship can represent the function calling relationship between warehouses with remote calls. In this way, it is equivalent to forming a code warehouse (i.e., Full function calling relationships between at least two of the above code repositories).

In a possible implementation, a document or a list may be generated according to the first calling relationship and the second calling relationship to characterize the above function calling relationship.

Optionally, in order to make the function calling relationship more intuitive, the function calling relationship can also be represented by a call graph. Therefore, in another embodiment, step 14 may include the following steps:

Determine function nodes based on the functions contained in at least two code repositories;

According to the first calling relationship, determine the first calling edge used to represent internal calls in the code warehouse, and the first calling edge is used to connect function nodes in the same code warehouse;

According to the second calling relationship, determine a second calling edge used to represent cross-code repository calls, and the second calling edge is used to connect function nodes in different code repositories;

According to the function node, the first calling edge and the second calling edge, a function calling graph representing the function calling relationship is generated.

The first calling edge and the second calling edge correspond to the upstream function node that implements the call and the called downstream function node. Therefore, based on the first calling edge and the second calling edge, the function nodes involved in the code warehouse can be connected to each other. , thus forming a function call graph.

Optionally, the function call graph may also include warehouse nodes and edges used to characterize the service provision relationship between the warehouse and the entry function.

For example, the function call graph can be shown in Figure 2. Among them, the two nodes as root nodes are both warehouse nodes, and the other nodes are function nodes. Function nodes in the same warehouse are connected through the first call edge (for example, the call edge of function 3 calling function 5). Different warehouses The function nodes between are connected by a second call edge (for example, the call edge of function 5 calling function x).

In a possible implementation, in order to ensure the accuracy of reachability between functions, the calling edge can also be corrected to a certain extent to avoid reachability errors. Therefore, in this implementation, before the step of generating a function call graph representing a function call relationship based on the function node, the first call edge and the second call edge, the method provided by the present disclosure may further include the following steps:

If there is a target function node that meets the preset conditions, the calling edge is corrected, and the calling edge includes the first calling edge and/or the second calling edge.

Optionally, the preset conditions can be:

The in-degree of the call edge reaches a first threshold, the out-degree of the call edge reaches a second threshold, and the function corresponding to the function node dynamically calls the function corresponding to the downstream function node.

That is to say, if a function as a middleware has a large number of in-degrees and out-degrees of calling edges, and the middleware is dynamically called, this can easily lead to reachability errors. Therefore, the calling edges can be Make corrections.

In a possible implementation, correcting the calling edge may include the following steps:

A call edge between a target function node and a first function node located downstream of the target function node is deleted, and a call edge between a second function node located upstream of the target function node and the first function node is generated, wherein the function corresponding to the first function node, the function corresponding to the target function node, and the function corresponding to the second function node are located on a function call link.

For example, for the two call links of function f1→function f3→function f4 and f2→function f3→function f5, it is easy to form a function call graph as shown in Figure 3, which leads to confusion in the reachability of function f1→function f4 and function f2→function f5. Based on this, the two call edges of function f3→function f4 and function f3→function f5 can be deleted, and two call edges of function f1→function f4 and function f2→function f5 can be generated, as shown in Figure 4, to ensure the accuracy of reachability.

Through the above technical solution, the first calling relationship between the functions contained in at least two code repositories and the functions in the code repository is determined. For the target function with remote calling behavior in the code repository, the target service identifier and the target interface identifier of the remote call of the target function are determined. According to the target service identifier, the target interface identifier and the target mapping relationship, the target routing function of the remote call of the target function across the code repository is determined, and the second calling relationship between the target function and the target routing function is formed. Then, according to the first calling relationship and the second calling relationship, the function calling relationship between the functions in the code repository is generated. Thus, by constructing the mapping relationship between the code repository and the service, the corresponding code repository can be determined according to the remotely called service, and then the routing function that provides the remote calling interface can be clearly located to form a remote calling relationship between functions. In this way, even in the scenario of calling data across warehouses, a clear calling relationship between functions can still be formed, which is conducive to the discovery of security risks and the information confirmation of data transmission between services based on the calling relationship.

Optionally, the method provided by the present disclosure may also include the following steps:

The function node, the first call edge, and the second call edge are stored in an online graph database.

In this way, online query needs can be met through the online graph database, and the response is faster.

In a possible implementation, the method provided by the present disclosure may further include the following steps:

Receive a data update instruction, the data update instruction carries data change information within a specified update period, and the data change information includes at least one of change information of the function node, change information of the first calling edge, and change information of the second calling edge;

In response to the data update instructions, the graph database is updated.

For example, the specified update period may be 1 day. In other words, the changed function nodes or call edges are determined in units of days, and the changes are updated to the graph database in units of days.

The reason for this processing is that the performance of the graph database is limited. If the full amount is imported every time, the performance of the graph data is not enough. Therefore, the changed parts can be imported periodically according to the specified update cycle to ensure performance and meet the requirements. online search. It should be noted that when synchronizing content such as nodes and calling edges to the graph database for the first time, you can import them in full.

In a possible implementation, the method provided by the present disclosure may further include the following steps:

receiving a first type of query instruction, where the first type of query instruction is used to query a function call relationship of a first function;

In response to the first type of query instruction, determine the function node corresponding to the first function in the graph database;

Determine the function node list and the calling edge list of the calling link where the function node corresponding to the first function is located, and the calling edge list includes the first calling edge and/or the second calling edge;

Based on the function node list and the calling edge list, query results are generated and output.

After receiving the first type of query instruction, the function node corresponding to the first function queried by the first type of query instruction can be determined. This step can be achieved by using the function name as the function identifier. Furthermore, the function node corresponding to the first function can be located from the graph database. Taking the function node as the starting point, the function nodes with calling relationships are determined step by step upwards and downwards until the root node and leaf node are found. In this way, In this way, the calling link of the first function is known, and the function nodes and calling edges passed during the search process can be formed into lists respectively as query results. For example, query results can be output via JSON.

In this way, users can be provided with direct query functions through the online graph database, which is simple and convenient.

Optionally, in the present disclosure, the content obtained through static code analysis (e.g., functions contained in the code repository, calling relationships between functions in the code repository, external interfaces provided by the code repository, services and interfaces for remote calls of functions in the code repository, etc.) can be stored in a document-based database (e.g., MongoDB) because the data generated by code analysis is huge and the fields required for code analysis may change. For example, the document-based database can be set online.

In a possible implementation, the method provided by the present disclosure may further include the following steps:

Receive a second type of query instruction, which is used to query the function calling relationship of the second function;

In response to the second type of query instruction, the first calling relationship corresponding to the second function in the document database is determined and output.

After receiving the second type of query instruction, the relevant information corresponding to the second function can be located from the document database, and then the first calling relationship corresponding to the second function is determined for output. It should be noted that the complete call chain cannot be obtained based on the second type of query instructions. Only the upper-level or lower-level functions that have a calling relationship with the second function (calls within the warehouse) can be queried.

Optionally, in the present disclosure, the data of the above-mentioned document database can also be synchronized to an offline database (such as a Hive data table) for users to perform offline queries through SQL statements.

Optionally, in the present disclosure, the content obtained after static code analysis and the information about the first calling edge can be stored in an online document-type database, and the content can be synchronized to an offline database, and can be retrieved through the offline database Obtain the information related to remote calls, conduct remote call between functions and analyze the second call edge offline, and then store the analysis results in a data table. The data table stores a full amount of point tables and edge tables. Based on the data table The content is synchronized to the graph database (i.e., full import for the first time, followed by periodic synchronization based on change information). By way of example, FIG. 5 shows a general flow diagram of the present disclosure. Among them, static code analysis can be implemented through analysis engines such as Golang, Python, Node, and Java.

In one possible scenario, through the method provided by this disclosure, full-link combing of security vulnerabilities can be achieved. For example, after determining a potential risky function, you can quickly locate all code repositories that call the risky function based on the function call relationship (such as a function call graph) determined in this disclosure to avoid risks in advance.

In another possible scenario, risk investigation can be implemented through the method provided by this disclosure. For example, for businesses involving confidential or sensitive data, the services provided by the code warehouse usually require strict permission verification. If the permission verification function is not used in the call chain of the service, the service may have potential risks. Risk, based on the function call relationship (such as function call graph) determined by this disclosure, it is very convenient to judge whether the permission verification function is used from a global perspective, so as to implement risk investigation.

Figure 6 is a block diagram of a cross-code repository calling relationship determination device provided by an embodiment of the present disclosure. As shown in Figure 6, the device 80 includes:

The first determination module 81 is used to determine the first calling relationship between the functions contained in at least two code warehouses and the functions in the code warehouse;

A second determination module 82 is used to determine, for a target function in the code repository that has a remote call behavior, a target service identifier and a target interface identifier for the remote call of the target function;

The third determination module 83 is used to determine the target routing function that the target function calls remotely across the code warehouse according to the target service identifier, the target interface identifier and the target mapping relationship, and form the target function and the target The second calling relationship between routing functions, wherein the target mapping relationship is used to indicate the mapping relationship between the code warehouse and the service;

The first generation module 84 is configured to generate a function calling relationship between functions included in the at least two code repositories based on the first calling relationship and the second calling relationship.

Optionally, the target mapping relationship is determined through the following modules:

The fourth determination module is used to determine the correspondence between the service identifier of the service and the interface identifier of the service;

The fifth determination module is used to determine the correspondence between the warehouse identification of the code warehouse and the interface identification of the code warehouse;

The second generation module is used to generate the target mapping relationship according to the service identifier and the warehouse identifier associated with the same interface identifier.

Optionally, the third determination module 83 includes:

The first determination sub-module is used to determine the target code warehouse corresponding to the target service identifier according to the target mapping relationship;

The second determination submodule is used to determine a function in the target code repository where the interface corresponding to the target interface identifier is located as the target routing function.

Optionally, the first generation module 84 includes:

The third determination sub-module is used to determine function nodes based on the functions contained in the at least two code repositories;

a fourth determining submodule, configured to determine, according to the first calling relationship, a first calling edge for characterizing a call within the code repository, wherein the first calling edge is used to connect function nodes in the same code repository;

The fifth determination sub-module is used to determine the second calling edge used to represent cross-code warehouse calls according to the second calling relationship, and the second calling edge is used to connect function nodes in different code warehouses;

Generating a submodule, configured to generate a function call graph representing a function call relationship based on the function node, the first calling edge, and the second calling edge.

Optionally, the device 80 also includes:

The correction module, before the generation submodule generates a function call graph for characterizing the function call relationship based on the function node, the first call edge and the second call edge, if there is a target function node that meets the preset conditions, the call edge is corrected, and the call edge includes the first call edge and/or the second call edge.

Optionally, the preset conditions are:

The in-degree of the calling edge reaches the first threshold, the out-degree of the calling edge reaches the second threshold, and the function corresponding to the function node dynamically calls the function corresponding to the downstream function node.

Optionally, the correction module is used to: delete the call edge between the target function node and a first function node located downstream of the target function node, and generate a call edge between a second function node located upstream of the target function node and the first function node, wherein the function corresponding to the first function node, the function corresponding to the target function node, and the function corresponding to the second function node are located on a function call link.

Optionally, the device 80 also includes:

The function node, the first call edge, and the second call edge are stored in an online graph database.

Optionally, the device 80 also includes:

The first receiving module is used to receive data update instructions. The data update instructions carry data change information within a specified update period. The data change information includes change information of function nodes, change information of the first calling edge, second Call at least one of the change information of the edge;

An update module, configured to update the graph database in response to the data update instruction.

Optionally, the device 80 further includes:

The second receiving module is used to receive the first type of query instructions, and the first type of query instructions are used to query the function calling relationship of the first function;

A sixth determination module, configured to determine the function node corresponding to the first function in the graph database in response to the first type of query instruction;

The seventh determination module is used to determine the function node list and the calling edge list of the calling link where the function node corresponding to the first function is located, and the calling edge list includes the first calling edge and/or the second calling edge;

The third generation module is used to generate query results according to the function node list and the calling edge list and output them.

Regarding the devices in the above embodiments, the specific manner in which each module performs operations has been described in detail in the embodiments related to the method, and will not be described in detail here.

Referring to FIG. 7 , a schematic diagram of the structure of an electronic device 600 suitable for implementing the embodiment of the present disclosure is shown. The terminal device in the embodiment of the present disclosure may include, but is not limited to, mobile terminals such as mobile phones, laptop computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. The electronic device shown in FIG. 7 is only an example and should not bring any limitation to the functions and scope of use of the embodiment of the present disclosure.

As shown in FIG. 7 , the electronic device 600 may include a processing device (eg, central processing unit, graphics processor, etc.) 601 , which may be loaded into a random access device according to a program stored in a read-only memory (ROM) 602 or from a storage device 608 . The program in the memory (RAM) 603 executes various appropriate actions and processes. In the RAM 603, various programs and data required for the operation of the electronic device 600 are also stored. The processing device 601, ROM 602 and RAM 603 are connected to each other via a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.

Generally, the following devices may be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touch pad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; including, for example, a liquid crystal display (LCD), speakers, vibration An output device 607 such as a computer; a storage device 608 including a magnetic tape, a hard disk, etc.; and a communication device 609. Communication device 609 may allow electronic device 600 to communicate wirelessly or wiredly with other devices to exchange data. Although FIG. 7 illustrates electronic device 600 with various means, it should be understood that implementation or availability of all illustrated means is not required. More or fewer means may alternatively be implemented or provided.

In particular, according to embodiments of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product including a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the method illustrated in the flowchart. In such embodiments, the computer program may be downloaded and installed from the network via communication device 609, or from storage device 608, or from ROM 602. When the computer program is executed by the processing device 601, the above functions defined in the method of the embodiment of the present disclosure are performed.

It should be noted that the computer-readable medium mentioned above in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium, or any combination of the above two. The computer-readable storage medium may be, for example, but is not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, or any combination thereof. More specific examples of computer readable storage media may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard drive, random access memory (RAM), read only memory (ROM), removable Programmed read-only memory (EPROM or flash memory), fiber optics, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In this disclosure, a computer-readable storage medium may be any tangible medium that contains or stores a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code therein. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium that can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device . Program code embodied on a computer-readable medium may be transmitted using any suitable medium, including but not limited to: wire, optical cable, RF (radio frequency), etc., or any suitable combination of the above.

In some embodiments, the client and server can communicate using any currently known or future developed network protocol such as HTTP (HyperText Transfer Protocol), and can communicate with digital data in any form or medium. (e.g., communications network) interconnection. Examples of communications networks include local area networks ("LAN"), wide area networks ("WAN"), the Internet (e.g., the Internet), and end-to-end networks (e.g., ad hoc end-to-end networks), as well as any currently known or developed in the future network of.

The above-mentioned computer-readable medium may be included in the above-mentioned electronic device; it may also exist independently without being assembled into the electronic device.

The computer-readable medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device: determines the functions contained in at least two code warehouses and the functions in the code warehouse. The first calling relationship between them; for the target function with remote calling behavior in the code warehouse, determine the target service identifier and target interface identifier of the remote call of the target function; according to the target service identifier, the target interface identifier and a target mapping relationship to determine the target routing function that the target function calls remotely across the code warehouse, and form a second calling relationship between the target function and the target routing function, where the target mapping relationship is used to indicate Mapping relationship between code repositories and services; generating a function calling relationship between functions contained in the at least two code repositories based on the first calling relationship and the second calling relationship.

Computer program code for performing the operations of the present disclosure may be written in one or more programming languages, including but not limited to object-oriented programming languages—such as Java, Smalltalk, C++, and Includes conventional procedural programming languages - such as "C" or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In situations involving remote computers, the remote computer can be connected to the user's computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as an Internet service provider). connected via the Internet).

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operations of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of code that contains one or more logic functions that implement the specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown one after another may actually execute substantially in parallel, or they may sometimes execute in the reverse order, depending on the functionality involved. It will also be noted that each block of the block diagram and/or flowchart illustration, and combinations of blocks in the block diagram and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or operations. , or can be implemented using a combination of specialized hardware and computer instructions.

The modules involved in the embodiments of the present disclosure can be implemented in software or hardware. Among them, the name of the module does not constitute a limitation on the module itself under certain circumstances. For example, the first determination module can also be described as “determining the functions contained in at least two code warehouses and the functions in the code warehouse. The first calling relationship between modules".

The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, and without limitation, exemplary types of hardware logic components that may be used include: Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), Systems on Chips (SOCs), Complex Programmable Logical device (CPLD) and so on.

In the context of this disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media may include, but are not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media would include electrical connections based on one or more wires, laptop disks, hard drives, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above.

According to one or more embodiments of the present disclosure, a method for determining call relationships across code repositories is provided, and the method includes:

Determine the first calling relationship between functions contained in at least two code repositories and functions in the code repositories;

For the target function with remote calling behavior in the code warehouse, determine the target service identifier and target interface identifier of the remote call of the target function;

According to the target service identifier, the target interface identifier and the target mapping relationship, determine the target routing function that the target function remotely calls across the code repository, and form a second calling relationship between the target function and the target routing function, wherein the target mapping relationship is used to indicate a mapping relationship between a code repository and a service;

According to the first calling relationship and the second calling relationship, a function calling relationship between functions included in the at least two code repositories is generated.

According to one or more embodiments of the present disclosure, a method for determining a call relationship across code repositories is provided, and the target mapping relationship is determined in the following manner:

Determine the correspondence between the service identifier of the service and the interface identifier of the service;

Determine the correspondence between the warehouse identification of the code warehouse and the interface identification of the code warehouse;

The target mapping relationship is generated according to the service identifier and the warehouse identifier associated with the same interface identifier.

According to one or more embodiments of the present disclosure, a method for determining a cross-code repository calling relationship is provided. The target function is determined based on the target service identifier, the target interface identifier and the target mapping relationship. The target routing function of the warehouse remote call includes:

Determine, according to the target mapping relationship, a target code repository corresponding to the target service identifier;

Determine the function in the target code repository where the interface corresponding to the target interface identifier is located as the target routing function.

According to one or more embodiments of the present disclosure, a method for determining a calling relationship across code repositories is provided, wherein the at least two code repositories are generated based on the first calling relationship and the second calling relationship. Function calling relationships between included functions, including:

Determine function nodes according to the functions contained in the at least two code repositories;

According to the first calling relationship, determine a first calling edge used to characterize internal calls in the code warehouse, and the first calling edge is used to connect function nodes in the same code warehouse;

According to the second calling relationship, determine a second calling edge used to characterize cross-code repository calls, and the second calling edge is used to connect function nodes in different code repositories;

A function call graph for representing a function call relationship is generated according to the function node, the first call edge, and the second call edge.

According to one or more embodiments of the present disclosure, a method for determining a calling relationship across code warehouses is provided, in which a method for determining a calling relationship is generated based on the function node, the first calling edge and the second calling edge. Before the step of forming a function call graph characterizing the function call relationship, the method further includes:

If there is a target function node that meets the preset conditions, correction processing is performed on the calling edge, which includes the first calling edge and/or the second calling edge.

According to one or more embodiments of the present disclosure, a method for determining call relationships across code repositories is provided, and the preset conditions are:

The in-degree of the calling edge reaches the first threshold, the out-degree of the calling edge reaches the second threshold, and the function corresponding to the function node dynamically calls the function corresponding to the downstream function node.

According to one or more embodiments of the present disclosure, a method for determining a call relationship across code repositories is provided, wherein the correction processing of the call edge includes:

Delete a call edge between the target function node and a first function node located downstream of the target function node, and generate a call edge between a second function node located upstream of the target function node and the first function node, wherein the function corresponding to the first function node, the function corresponding to the target function node, and the function corresponding to the second function node are located on a function call link.

According to one or more embodiments of the present disclosure, a method for determining call relationships across code repositories is provided, and the method further includes:

The function node, the first calling edge and the second calling edge are stored in an online graph database.

According to one or more embodiments of the present disclosure, a method for determining call relationships across code repositories is provided, and the method further includes:

receiving a data update instruction, the data update instruction carrying data change information within a specified update period, the data change information including at least one of change information of a function node, change information of a first call edge, and change information of a second call edge;

In response to the data update instruction, the graph database is updated.

According to one or more embodiments of the present disclosure, a method for determining call relationships across code repositories is provided, and the method further includes:

receiving a first type of query instruction, where the first type of query instruction is used to query a function call relationship of a first function;

In response to the first type of query instruction, determining a function node in the graph database corresponding to the first function;

Determine the function node list and the calling edge list of the calling link where the function node corresponding to the first function is located, and the calling edge list includes the first calling edge and/or the second calling edge;

According to the function node list and the calling edge list, query results are generated and output.

According to one or more embodiments of the present disclosure, a device for determining call relationships across code repositories is provided, and the device includes:

A first determining module, configured to determine a first calling relationship between functions included in at least two code repositories and functions in the code repositories;

The second determination module is used to determine the target service identifier and target interface identifier of the remote call of the target function for the target function in the code warehouse that has remote calling behavior;

The third determination module is used to determine the target routing function that the target function calls remotely across the code warehouse according to the target service identifier, the target interface identifier and the target mapping relationship, and form the target function and the target route The second calling relationship between functions, wherein the target mapping relationship is used to indicate the mapping relationship between the code warehouse and the service;

A first generation module, configured to generate a function calling relationship between functions included in the at least two code repositories based on the first calling relationship and the second calling relationship.

According to one or more embodiments of the present disclosure, a computer-readable medium is provided, on which a computer program is stored. When the program is executed by a processing device, the cross-code repository calling relationship determination method described in any embodiment of the present disclosure is implemented. A step of.

According to one or more embodiments of the present disclosure, there is provided an electronic device, including:

a storage device having a computer program stored thereon;

A processing device, configured to execute the computer program in the storage device to implement the steps of the cross-code repository calling relationship determination method described in any embodiment of the present disclosure.

The above description is only a description of the preferred embodiments of the present disclosure and the technical principles applied. Those skilled in the art should understand that the disclosure scope involved in the present disclosure is not limited to technical solutions composed of specific combinations of the above technical features, but should also cover solutions that are composed of the above technical features or without departing from the above disclosed concept. Other technical solutions formed by any combination of equivalent features. For example, a technical solution is formed by replacing the above features with technical features with similar functions disclosed in this disclosure (but not limited to).

Furthermore, although operations are depicted in a specific order, this should not be understood as requiring that these operations be performed in the specific order shown or performed in a sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Likewise, although several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are merely example forms of implementing the claims. Regarding the devices in the above embodiments, the specific manner in which each module performs operations has been described in detail in the embodiments related to the method, and will not be described in detail here.

Claims (13)

1. A method for determining call relationships across code warehouses, characterized in that the method includes: Determine the first calling relationship between functions contained in at least two code repositories and functions in the code repositories; For a target function in the code repository that has a remote call behavior, determine a target service identifier and a target interface identifier for the remote call of the target function; According to the target service identifier, the target interface identifier and the target mapping relationship, determine the target routing function that the target function calls remotely across the code warehouse, and form a second call between the target function and the target routing function Relationship, wherein the target mapping relationship is used to indicate the mapping relationship between the code warehouse and the service; According to the first calling relationship and the second calling relationship, a function calling relationship between functions included in the at least two code repositories is generated. 2. The method according to claim 1, characterized in that the target mapping relationship is determined in the following manner: Determine the correspondence between the service identifier of the service and the interface identifier of the service; Determine the correspondence between the warehouse identification of the code warehouse and the interface identification of the code warehouse; The target mapping relationship is generated according to the service identifier and the warehouse identifier associated with the same interface identifier. 3. The method of claim 1, wherein determining the target routing function for remote calling of the target function across code warehouses according to the target service identifier, the target interface identifier and the target mapping relationship includes: : According to the target mapping relationship, determine the target code warehouse corresponding to the target service identifier; Determine the function in the target code repository where the interface corresponding to the target interface identifier is located as the target routing function. 4. The method according to claim 1, characterized in that, according to the first calling relationship and the second calling relationship, a function calling relationship between functions contained in the at least two code warehouses is generated. ,include: Determine a function node according to the functions included in the at least two code repositories; According to the first calling relationship, determine a first calling edge used to characterize internal calls in the code warehouse, and the first calling edge is used to connect function nodes in the same code warehouse; Determine, according to the second call relationship, a second call edge for characterizing a cross-code repository call, where the second call edge is used to connect function nodes in different code repositories; According to the function node, the first calling edge and the second calling edge, a function calling graph representing a function calling relationship is generated. 5. The method according to claim 4, characterized in that, according to the function node, the first calling edge and the second calling edge, a function call graph representing a function calling relationship is generated. Before step, the method also includes: If there is a target function node that meets the preset conditions, the call edge is modified, and the call edge includes the first call edge and/or the second call edge. 6. The method according to claim 5, characterized in that the preset condition is: The in-degree of the calling edge reaches the first threshold, the out-degree of the calling edge reaches the second threshold, and the function corresponding to the function node dynamically calls the function corresponding to the downstream function node. 7. The method according to claim 5, characterized in that the correction process on the calling edge includes: Delete the call edge between the target function node and the first function node located downstream of the target function node, and generate a call between the second function node located upstream of the target function node and the first function node Edge, wherein the function corresponding to the first function node, the function corresponding to the target function node, and the function corresponding to the second function node are located on a function call link. 8. The method according to claim 4, characterized in that, the method further comprises: The function node, the first calling edge and the second calling edge are stored in an online graph database. 9. The method according to claim 8, characterized in that the method further comprises: receiving a data update instruction, the data update instruction carrying data change information within a specified update period, the data change information including at least one of change information of a function node, change information of a first call edge, and change information of a second call edge; In response to the data update instruction, the graph database is updated. 10. The method according to claim 8, characterized in that the method further comprises: Receive a first type of query instruction, the first type of query instruction is used to query the function calling relationship of the first function; In response to the first type of query instruction, determine the function node corresponding to the first function in the graph database; Determine the function node list and the calling edge list of the calling link where the function node corresponding to the first function is located, where the calling edge list includes the first calling edge and/or the second calling edge; According to the function node list and the calling edge list, query results are generated and output. 11. A device for determining calling relationships across code warehouses, characterized in that the device includes: A first determination module, configured to determine a first calling relationship between functions contained in at least two code repositories and functions in the code repositories; The second determination module is used to determine the target service identifier and target interface identifier of the remote call of the target function for the target function in the code warehouse that has remote calling behavior; The third determination module is used to determine the target routing function that the target function calls remotely across the code warehouse according to the target service identifier, the target interface identifier and the target mapping relationship, and form the target function and the target route The second calling relationship between functions, wherein the target mapping relationship is used to indicate the mapping relationship between the code warehouse and the service; A first generation module, configured to generate a function calling relationship between functions included in the at least two code repositories based on the first calling relationship and the second calling relationship. 12. A computer-readable medium having a computer program stored thereon, characterized in that when the program is executed by a processing device, the steps of the method according to any one of claims 1 to 10 are implemented. 13. An electronic device, comprising: a storage device having a computer program stored thereon; A processing device, configured to execute the computer program in the storage device to implement the steps of the method according to any one of claims 1-10.