CN115794183A - Upgrading method, upgrading device, electronic equipment and computer readable storage medium - Google Patents

Abstract

The application discloses an upgrading method, an upgrading device, electronic equipment and a computer readable storage medium. The method is applied to a manager, and the method for maintaining codes through the manager comprises the following steps: receiving a function upgrading instruction; generating a registry updating instruction according to the function upgrading instruction, and sending the registry updating instruction to the client, so that the first registry stored in the client is updated into a second registry in the process that at least one function in codes related to a second process running in the client calls a first function, and the second process determines the function called by at least one function in the codes related to the second process according to the registry stored in the client; and generating indication information according to the function upgrading instruction, and sending the indication information to the server side, so that the server side upgrades the compiled file of the first code into the compiled file of the second code, and the first function is upgraded into the second function. The method completes the upgrading of the service under the condition of not interrupting the service.

Description

Upgrading method, upgrading device, electronic equipment and computer readable storage medium

Technical Field

The present application relates to the field of network technologies, and in particular, to an upgrade method, an upgrade apparatus, an electronic device, and a computer-readable storage medium.

Background

Remote Procedure Call (RPC) is a technique in which one process calls a method provided by another process. In the remote procedure call, all parameters to be provided for the called end process are serialized into a network message by the calling end process and then are transmitted to the called end process through network transmission. After the called end completes the corresponding service, the generated result is also serialized into a network message and sent to the calling end process.

In the process of calling a method provided by another process by using an RPC in one process, if the method provided by the process to be called needs to be upgraded, interrupt processing needs to be performed on the two processes in the traditional technology, and the two processes are not switched into a running state from an interrupt state until the method provided by the process to be called is upgraded. That is, in the conventional upgrade technique, the service associated with the two processes needs to be completely interrupted.

Therefore, there is a need for an upgrade method that can complete the upgrade of the service without interrupting the service.

Disclosure of Invention

The application provides an upgrading method, an upgrading device, electronic equipment and a computer readable storage medium.

A first aspect of an embodiment of the present application provides an upgrade method, which is applied to a manager, where a code is maintained by the manager, and the method includes: receiving a function upgrading instruction, wherein the function upgrading instruction instructs that a first function in first codes associated with a first process running in a server is upgraded into a second function, and the second function is different from the first function; generating a registry updating instruction according to the function upgrading instruction, and sending the registry updating instruction to a client, so that a first registry stored in the client is updated into a second registry in the process of calling the first function by at least one function in codes associated with a second process running in the client, wherein the second process determines a function called by at least one function in the codes associated with the second process according to the registry stored in the client, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry; generating indication information according to the function upgrading instruction, and sending the indication information to the server, so that the server upgrades the compiled file of the first code into the compiled file of the second code, and upgrades the first function into the second function; wherein the indication information indicates a compiled file of the second code, the code including at least the first code and the second code, the second code being a code obtained by the manager executing the operation indicated by the upgrade instruction on the first code.

A second aspect of the present embodiment also provides an upgrade method, which is applied to a server, and the method includes: receiving indication information from a manager, wherein the indication information indicates a compiled file of second code, the second code is obtained by executing, by the manager, an operation indicated by a function upgrade instruction on a first function in first code associated with a first process running in the server, the function upgrade instruction indicates that the first function in the first code is upgraded into a second function, and the second function is different from the first function; according to the indication information, obtaining a compiled file of the second code; and upgrading the compiled file of the first code to the compiled file of the second code under the condition that the first process is in a running state, so as to upgrade the first function to the second function.

A third aspect of the present embodiment further provides an upgrade method, applied to a client, where the method includes: receiving a registry updating instruction from a manager, wherein the registry updating instruction is generated by the manager according to a function upgrading instruction, the function upgrading instruction indicates that a first function in a first code associated with a first process running in a server is upgraded to a second function, the second function is different from the first function, the registry updating instruction is used for indicating that a first registry stored in the client is updated to a second registry, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry; and updating the first registry to a second registry according to the registry updating instruction in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client.

The fourth aspect of the embodiments of the present application further provides an upgrade apparatus, which is applied to a manager, where a code is maintained by the manager, and the apparatus includes: the system comprises a receiving and sending unit, a processing unit and a processing unit, wherein the receiving and sending unit is used for receiving a function upgrading instruction, the function upgrading instruction indicates that a first function in first codes related to a first process running in a server is upgraded into a second function, and the second function is different from the first function; a processing unit, configured to generate a registry update instruction according to the function upgrade instruction, where the transceiver unit is further configured to: sending the registry updating instruction to a client to update a first registry stored in the client into a second registry in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines a function called by at least one function in the codes associated with the second process according to the registry stored in the client, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry; the processing unit is further to: generating indication information according to the function upgrade instruction, wherein the transceiver unit is further configured to: sending the indication information to the server, and upgrading the compiling file of the first code into a compiling file of a second code so as to upgrade the first function into the second function; wherein the indication information indicates a compiled file of the second code, the code including at least the first code and the second code, the second code being a code obtained by the manager performing an operation indicated by the function upgrade instruction on the first code.

The fifth aspect of the embodiment of the present application further provides an upgrading apparatus, which is applied to a server, where the apparatus includes: a transceiver unit, configured to receive indication information from a manager, where the indication information indicates a compiled file of a second code, where the second code is obtained by the manager performing an operation indicated by a function upgrade instruction on a first function in a first code associated with a first process running in the server, and the function upgrade instruction indicates to upgrade the first function in the first code to a second function, where the second function is different from the first function; the processing unit is used for: according to the indication information, obtaining a compiled file of the second code; the processing unit is further to: and upgrading the compiled file of the first code to the compiled file of the second code under the condition that the first process is in the running state, so as to upgrade the first function to the second function.

A sixth aspect of the embodiments of the present application further provides an upgrade apparatus, applied to a client, where the apparatus includes: a transceiver unit, configured to receive a registry update instruction from a manager, where the registry update instruction is generated by the manager according to a function upgrade instruction, the function upgrade instruction indicates that a first function in a first code associated with a first process running in a server is upgraded to a second function, the second function being different from the first function, the registry update instruction is used to indicate that a first registry stored in the client is upgraded to a second registry, first variable information associated with the first function is recorded in the first registry, second variable information associated with the second function is recorded in the second registry, and the first variable information is different from the second variable information; the processing unit is used for: and updating the first registry to a second registry according to the registry updating instruction in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client.

A seventh aspect of the embodiments of the present application further provides a computer-readable storage medium, having one or more computer instructions stored thereon, where the instructions are executed by a processor to implement the method according to any one of the above-mentioned technical solutions.

The eighth aspect of the embodiments of the present application further provides an electronic device, including: a processor; and the memory is used for storing a data processing program, and after the electronic equipment is powered on and runs the program through the processor, the method of any one of the technical schemes is executed.

It should be understood that the statements in this section are not intended to identify key or critical features of the embodiments of the present disclosure, nor are they intended to limit the scope of the present disclosure. Other features disclosed in the present application will become apparent from the following description.

The upgrading method provided by the embodiment of the application is applied to a manager, and codes are maintained through the manager and at least comprise a first code and a second code. And the manager determines to generate a registration updating instruction and indication information according to the received function upgrading instruction, sends the registration updating instruction to the client and sends the indication information to the server. The function upgrading instruction instructs that a first function in first codes associated with a first process running in the server is upgraded into a second function. The register updating instruction sent by the manager to the client instructs the client to update the first registry to the second registry so as to complete the upgrading operation indicated by the function upgrading instruction in the client. The indication information sent by the manager to the server instructs the server to upgrade the compiled file of the first code into the compiled file of the second code, so that the first function is upgraded into the second function. In this implementation manner, the server does not need to run a first process in the server to modify the first code into a second code, and only needs to upgrade a compiled file of the first code associated with the first process into a compiled file of the second code according to indication information sent by the manager, where the process of upgrading the compiled file by the server is a just-in-time compilation process (just-in-time compilation refers to a process in which compilation is performed during running of a process), and the just-in-time compilation process does not need to interrupt the first process running in the server. That is, in the above-described upgrading method, it is not necessary to interrupt the second process running in the client, nor the first process running in the server. In conclusion, the method completes the upgrading of the service under the condition of not interrupting the service.

The upgrading method provided by the embodiment of the application is applied to a server, and the server receives indication information sent by a manager, wherein the indication information indicates the server to upgrade a compiled file of a first code into a compiled file of a second code so as to upgrade a first function into a second function. In this implementation manner, the server does not need a first process running in the server to modify the first code into a second code, and only needs to upgrade a compiled file of the first code associated with the first process into a compiled file of the second code according to indication information sent by the manager, where the process of upgrading the compiled file by the server is a just-in-time compilation process (the just-in-time compilation refers to a process of compiling during process running), and the just-in-time compilation process does not need to interrupt the first process running in the server. That is, in the above upgrading method, the first process running in the server does not need to be interrupted. In conclusion, the method completes the upgrading of the service of the first process running in the server under the condition of not interrupting the service.

The upgrading method provided by the embodiment of the application is applied to the client, the client receives the registration updating instruction sent by the manager, and the registration updating instruction indicates the client to update the first registry to the second registry. The client updates the first registry stored in the client into the second registry according to the received registration updating instruction so as to complete the updating operation indicated by the function updating instruction in the client. In conclusion, the method completes the upgrading of the service of the second process running in the client under the condition of not interrupting the service.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the description of the embodiments of the present application will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art that other drawings can be obtained according to these drawings without inventive exercise.

Fig. 1 is a schematic diagram of an application scenario applicable to the upgrading method provided in the embodiment of the present application.

Fig. 2 is a schematic structural diagram of the client 110, the server 120, and the manager 130 included in the application scenario illustrated in fig. 1.

Fig. 3 is a schematic diagram of a computing device 300 suitable for the upgrade method provided in the embodiment of the present application.

Fig. 4 is a schematic diagram of an upgrade method provided in an embodiment of the present application.

Fig. 5 is a schematic diagram of another upgrading method provided in an embodiment of the present application.

Fig. 6 is a schematic diagram of an upgrading apparatus provided in an embodiment of the present application.

Fig. 7 is a schematic structural diagram of an upgrade system provided in an embodiment of the present application.

Fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

In order to enable those skilled in the art to better understand the technical solution of the present application, the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. This application is capable of embodiments in many different forms than those described above and it is therefore intended that all such other embodiments, which would be within the scope of the present application and which are obtained by a person of ordinary skill in the art based on the embodiments provided herein without the exercise of inventive faculty, be covered by the present application.

It should be noted that the terms "first," "second," "third," and the like in the claims, the description, and the drawings of the present application are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. The data so used is interchangeable under appropriate circumstances such that the embodiments of the application described herein are capable of operation in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

For the sake of easy understanding, first, technical terms that may be referred to in the embodiments of the present application are briefly described.

Remote Procedure Call (RPC)

Remote procedure calls are a computer communication protocol that allow a program running on one computer to call a subroutine on another computer without the need to additionally program this interaction. Wherein, the RPC calling process is as follows:

step 1: a caller (namely Client) initiates a call in a local call mode;

step 2: after receiving the call, the Client stub (Client stub) is responsible for packing and encoding the called method name, parameters and the like into a message body which has a specific format and can be transmitted through a network according to an RPC message protocol;

and step 3: the Client stub sends the message body to a server through a network according to an RPC transmission protocol;

and 4, step 4: after receiving a message received through a network, a Server stub (Server stub) unpacks and decodes the message according to a corresponding format and an RPC message protocol to obtain a method name and parameters;

and 5: the Server stub carries out local calling according to the method name and the parameters;

step 6: the called party (namely the Server) returns the result to the Server stub after locally calling and executing;

and 7: the Server stub packs and encodes the return value into a message according to an RPC message protocol, and sends the message to the client through the network according to an RPC transmission protocol;

and step 8: and after receiving the message, the Client stub unpacks and decodes the message according to an RPC message protocol, and returns the message to the Client.

And step 9: and the Client obtains the final result of the RPC call.

Wherein, the RPC message protocol: the method is a protocol for packing, encoding and unpacking data transmitted on the network by a parameter called by a client and a return value of a server in a specified mode. RPC transmission protocol: is a protocol for transmitting message data. The RPC transport protocols include HTTP transport and TCP transport.

2, process (Process)

A process is a running activity of a program with independent functionality with respect to a certain data set. A process also refers to an application that is running in the system. A process can apply for and own system resources, the process is a dynamic concept, and the process is an active entity. The process is not just the code of the program, but the process also includes the current activity, represented by the value of the program counter and the contents of the processing registers. That is, the process has the following features: independence, dynamics, and concurrency. Wherein, the independence: the processes are independent entities in the system, can own independent resources, each process has own private address space, and one user process cannot directly access the address spaces of other processes under the condition of not allowing the processes. Generally, each process has an address space including a text region (text region), a data region (data region), and a stack (stack region). Wherein the text area stores code executed by the processor; a data area stores variables and dynamically allocated memory used during process execution; the stack area stores the instructions and local variables of the active procedure call. The dynamic property: the process is different from the program in that the program is only a static instruction set, the process is an instruction set which is active in the system, and the program is called the process after adding the concept of time, has the life cycle of the program and various different states, and the concepts are not possessed by the program. Concurrency: multiple processes can be executed concurrently on a single processor CPU without interaction between the processes.

3, thread (thread)

A thread is the smallest unit that an operating system can perform computational scheduling. Threads are included in a process and are the actual unit of operation in the process. A thread refers to a single sequential control flow in a process, multiple threads can be concurrently executed in a process, and each thread executes different tasks in parallel. Multiple threads in the same process will share all system resources in the process, such as virtual address space, file descriptors, signal processing, etc. However, multiple threads in the same process have their own call stack (call stack), their own register context (register context), and their own thread local storage (local storage).

4, memory space

In a computer, memory space generally refers to main memory space (physical address space) or memory space allocated by a system for a user program. A memory address is a number that represents a memory space.

5, compilation (compilation)

And compiling, namely generating a target program from a source program written in a source language by using a compiler program. Compiling is to change a High-Level Language (High Level Language) into a binary Language which can be recognized by a computer. Wherein, the high-level language has the following characteristics: the method is similar to mathematical definition or a concise form of natural language, is close to human expression habit, does not depend on a specific machine, and has high writing efficiency.

6, source code (Source Coding)

Source code, also known as source program or logic code. The source code is an uncompiled text file written according to a certain programming language specification and is a series of human-readable computer language instructions. In modern programming languages, the source code may be in the form of a book or tape, but the most common format is a text file, which is typically intended for compiling a computer program. The ultimate purpose of computer source code is to translate human-readable text into binary instructions that the computer can execute, a process called compilation, which is done by a compiler.

Hereinafter, an application scenario and an upgrade method applicable to the upgrade method provided in the embodiments of the present application are described in detail with reference to the drawings. It is understood that the features of the embodiments and examples described below can be combined with each other without conflict between the embodiments provided in this application. In addition, the sequence of steps in each method embodiment described below is only an example and is not strictly limited.

First, an application scenario applicable to the upgrade method provided in the embodiment of the present application is described with reference to fig. 1 to fig. 3.

Fig. 1 is a schematic diagram of an application scenario applicable to the upgrading method provided in the embodiment of the present application. Illustratively, as shown in fig. 1, the application scenario includes a client 110, a server 120, and a manager 130. Any two devices of the client 110, the server 120 and the manager 130 may communicate with each other through a wired network or a wireless network to implement data transmission. The wired or wireless network uses standard communication techniques and/or protocols. The network is typically the internet, but can be any network including, but not limited to, a Local Area Network (LAN), a Metropolitan Area Network (MAN), a Wide Area Network (WAN), a mobile, wired or wireless network, a private network, or any combination of virtual private networks.

Process 1 running in client 110 may call the method provided by process 2 running in server 120 using the remote procedure call RPC protocol. For example, the process 2 is a process for implementing the function 1, and in this implementation, the process 1 may call the process 2 by using RPC to obtain an execution result of the function 1. By updating the source code associated with the process 3 in the manager 130, the process 2 in the server 120 can update the compilation result of the source code associated with the process 2 in the server 120 (i.e., update the service associated with the process 2) without interrupting the running. Specifically, when the source code associated with the process 2 running in the server 120 needs to be updated, the developer updates the source code associated with the process 3 according to the update requirement to obtain the updated source code. Thereafter, the server 120 communicates with the manager 130, and the server 120 obtains the updated source code. The process 2 running in the server 120 loads the updated source code in a dynamic loading manner, compiles the updated source code to obtain a compilation result of the updated source code, and then updates the compilation result of the source code stored in the address space allocated to the process 2 in the server to the compilation result of the updated source code. The network transmission protocol used when data is transmitted between the client 110 and the server 120 is not particularly limited. For example, the network transmission protocol may be a transmission control protocol/internet protocol (TCP/IP) or a User Datagram Protocol (UDP) protocol.

In some implementations, the client 110, the server 120, and the manager 130 shown in fig. 1 are 3 separate physical devices. By way of example, fig. 2 shows a schematic structural diagram of the client 110, the server 120 and the manager 130 in this implementation. Referring to fig. 2, the client 110 may include a processor 1 and a memory 1, and a process 1 runs in the processor 1. The memory space 1 in the memory 1 is a space allocated to the process 1, and the memory space 1 is used for storing the code associated with the process 1, the parameters related to the code associated with the process 1, and the like. The server 120 includes a processor 2 and a memory 2, and a process 2 runs in the processor 2. The memory space 2 in the memory 2 is a space allocated to the process 2, and the memory space 2 is used for storing the code associated with the process 2, parameters related to the code associated with the process 2, and the like. The client 130 includes a processor 3 and a memory 3, and a process 3 runs in the processor 3. The memory space 3 in the memory 3 is a space allocated to the process 3, and the memory space 3 is used for storing the code associated with the process 3, parameters related to the code associated with the process 3, and the like.

In the configuration shown in FIG. 2, process 1 running in client 110 may call process 2 running in server 120 using the remote procedure call RPC protocol to obtain the method provided by process 2. The developer modifies the source code associated with the process 3 in the manager 130, so that the process 2 in the server 120 can update the compiling result of the source code associated with the process 2 in the server 120 without interrupting the running.

It should be understood that fig. 2 above is described with respect to any one of the devices including a processor and a memory. Optionally, any one of the devices shown in fig. 2 may further include a storage device (e.g., a hard disk), and the storage device may be configured to store an execution result of the process. Fig. 2 above is described by taking an example where a processor of any one of the devices runs a process. Optionally, multiple processes may also run in the processor of any one of the devices shown in fig. 2. In this implementation, the memory of any one of the devices may include a plurality of memory spaces, the plurality of processes correspond to the plurality of memory spaces one to one, and each memory space is a memory space allocated to a corresponding process.

Optionally, in other implementations, the client 110, the server 120, and the manager 130 shown in fig. 1 are the same physical device. For ease of description, the same physical device will be referred to hereinafter as computing device 300. That is, the computing device 300 has the functions of the client 110, the server 120, and the manager 130 shown in fig. 1 described above. By way of example, FIG. 3 illustrates a schematic diagram of a computing device 300. Referring to fig. 3, computing device 300 includes a processor 310 and memory 320. Processor 310 includes process 311, process 312, and process 313. Memory 320 includes memory space 312, memory space 322, and memory space 323. Wherein, the memory space 312 is a memory space allocated to the process 311; memory space 322 is the memory space allocated to process 312; memory space 323 is the memory space allocated to process 313.

Wherein the function of the process 311 is the same as that of the process 1 shown in fig. 1; the function of process 312 is the same as that of process 2 shown in FIG. 1; the function of the process 313 is the same as that of the process 3 shown in fig. 1. That is, the process 311 can call the program associated with the process 312 using the remote procedure call RPC protocol to obtain the execution result of the process 311. The developer updates the source code associated with the process 312 by modifying the source code associated with the process 313 and updating the source code associated with the process 3 in the manager 130, so that the process 312 can update the compiling result of the source code associated with the process 312 without interrupting the operation.

It should be understood that the description of fig. 3 above is presented with the computing device 300 including a processor and memory as an example. Optionally, the computing device 300 shown in fig. 3 may further include a storage device (e.g., a hard disk), and the storage device may be used for storing the execution result of the process.

In the embodiment of the present application, the type of the processor referred to in fig. 2 and 3 is not particularly limited. For example, the processor may be, but is not limited to, any one of the following: a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), a Digital Signal Processor (DSP), a microprocessor, or a microcontroller.

In the embodiment of the present application, the type of any one of the client 110, the server 120, the manager 130, and the computing device 300 related to fig. 1 to 3 is not specifically limited. In some implementations, the any one device may be various types of electronic devices having a display screen, for example, but not limited to, a personal computer, a smart phone, a tablet computer, a desktop computer, a vehicle recorder, or a wearable device (e.g., a smart watch), etc. The above is merely an example, and not an exhaustive list, and any one of the devices includes, but is not limited to, the electronic device described above, and the electronic device may further include a server, for example, a cloud server. Optionally, the manager 130 may also be a code editor running in the electronic device.

It should be understood that fig. 1 to fig. 3 are only schematic diagrams, and are not limited to any application scenario to which the upgrade method provided in the embodiment of the present application is applicable. That is, the number of devices (e.g., clients 110), the number of processes, and the number of memory spaces shown in fig. 1-3 above are merely illustrative. According to actual requirements, the number of devices, processes and memory spaces matched with the requirements can be set in the application scene.

With the development of network technology, business applications are increasingly requesting remote procedure calls from target service programs across the network to obtain service data. The service application program is used as a call initiator of the remote procedure call, the target service program is used as a service provider, and the service application program and the target service program carry out data interaction by adopting an RPC protocol. Briefly, RPC is a process that calls a method provided by another process. For example, taking the above fig. 2 as an example, process 1 in the client 110 may use RPC to call the method provided by process 2 in the server 120. When the process 1 in the client 110 calls the method provided by the process 2 in the server, the client 110 needs to send the function name to be called and the parameter associated with the function name to the server 120, so that the process 2 in the server 120 executes the corresponding method and obtains an execution result, and the server 120 sends the execution result to the client after obtaining the execution result, so as to implement that the process 1 in the client 110 calls the method provided by the process 2 in the server 120.

In the conventional technology, the function name to be called and the source code associated with the function name need to be written in the process 1 in the client 110 and the process 2 in the server 120, respectively, and the compilation results of the function name to be called and the source code associated with the function name need to be deployed in the address space allocated to the process 1 and the address space allocated to the process 2, respectively. For example, when the function to be called is named as eat function, the source code 1 associated with the eat function may be as follows:

eat(food)；

a＝food；

c＝20；

return a+c.

in practical applications, in order to better meet the user requirement, the method provided by the process 2 may be upgraded according to the user requirement (for example, parameters associated with the method or computing logic associated with the method are modified). When upgrading is performed in the conventional technology, source codes written in the process 1 and the process 2 need to be changed respectively according to business requirements, and the process 1 and the process 2 are in an interrupted state when the source codes written in the process 1 and the process 2 are changed. And restarting the server 120 and the client 110 to upgrade the method provided by the process 2 until the developer finishes changing the source code written by the process 1 and the process 2. Thereafter, the process 1 in the client 110 sends the function name and the parameter associated with the upgraded source code to the server 120, so that the process 2 in the server 120 executes the upgraded method and obtains a corresponding execution result, and the server 120 sends the corresponding execution result to the client 110 after obtaining the corresponding execution result. Continuing to take the function to be called before upgrading as the eat function example in the above example, respectively changing the source codes of the eat function written in the process 1 and the process 2 according to the service requirement, where the source codes of the eat function after upgrading can be as follows:

eat(food，speed)；

a＝food；

b＝speed；

c＝20；

return a*b+c.

in the above conventional upgrade process, it is necessary to perform interrupt processing on the process 1 running in the client 110 and the process 2 running in the server 120, that is, all services associated with the process 1 and all services associated with the process 2 need to be completely interrupted in the above upgrade process. The process 1 and the process 2 may load multiple services during operation, and only part of the multiple services associated with the process 2 may need to be upgraded during the upgrade process, so it is desirable that the process 1 and the process 2 are continuously operated during the upgrade process. In summary, in the conventional upgrading technology, there are problems that the service associated with the process 1 and the service associated with the process 2 need to be completely interrupted, and that the upgrading efficiency is low.

In order to solve the existing problems, the present application provides an upgrade method, an upgrade apparatus, an electronic device, and a computer-readable storage medium. Next, the upgrade method provided by the embodiment of the present application is described in detail with reference to fig. 4 and 5.

Fig. 4 is a schematic diagram of an upgrading method provided in an embodiment of the present application. It is understood that the client, the server and the manager in the method shown in fig. 4 may be, but are not limited to, the client 110, the server 120 and the manager 130 in the application scenario shown in fig. 1, in which case, the client 110 and the server 120 may be two different devices, or the client 110 and the server 120 may also be the same device. As shown in fig. 4, the upgrade method provided in the embodiment of the present application includes S401 to S406. Next, S401 to S406 will be described in detail.

S401, the manager receives a function upgrading instruction.

The manager described in S401 above is used to maintain codes, which include at least a first code and a second code described below. The code is associated with a function upgrade instruction. Next, the function upgrade instruction and the code will be described.

The function upgrading instruction instructs to upgrade a first function in first code associated with a first process running at the server to a second function, and the second function is different from the first function. That is, the function upgrade instruction is an instruction to perform an upgrade operation on a first function in first code associated with a first process running in the server. The first code may be understood as logic code, and in this case, the first code may also be referred to as first source code. The function in the first code associated with the first process is not particularly limited. For example, the function in the first code associated with the first process is only the first function. In this implementation, the first code is the code of the first function. As another example, the function in the first code associated with the first process includes a plurality of functions, including the first function. In this implementation, the first code is a code that includes a plurality of functions.

The second function is different from the first function, and is described in detail below.

In some implementations, the second function is different from the first function, which may be understood as the second function having the same identity as the first function and the first variable information being different from the second variable information. The identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function name of the second function. In this implementation, the function name of the second function is the same as the function name of the first function, but the variable information of the two functions is different. That is, in this implementation, the purpose of the upgrade is to perform an upgrade operation on the variable associated with the first function, where the variable information includes the variable and the value of the variable. That is, the upgrade operation may be performed on the type of the variable associated with the first function, or may also be performed on the value of the variable associated with the first function. In the following, the upgrade operation performed on the value of the variable associated with the first function is exemplified. For example, the first function is an eat function, a variable in the first variable information associated with the first function is food, and a value of the variable in the first variable information associated with the first function is fish; the second function is an eat function, a variable in second variable information associated with the second function is food, and a value of the variable in the second variable information is rice; that is, in this implementation, the purpose of the upgrade is to upgrade the value of the variable food in the eat function from fish to rice.

Optionally, the first variable information associated with the first function may be at least one variable information in a preset parameter set, and the second variable information associated with the second function may be at least one variable information in the preset parameter set. In this implementation, the first variable information and the second variable information are variable information included in a preset parameter set. The preset parameter set is also called a preset namespace, and comprises a plurality of parameters and values of the parameters. In the embodiment of the present application, the number and the type of the parameters included in the preset parameter set are not specifically limited. A user (e.g., a developer) may set a plurality of parameters included in the preset parameter set and values of the plurality of parameters according to an actual application situation. The location where the preset parameter set is stored is not particularly limited. For example, the preset parameter set may be stored in a storage space of any one of the client, the manager, or the server. For example, when the preset parameter set is expressed as { food: fish, speed:1, weight: food, speed, weight, color; the food parameter has a value of fish, the speed parameter has a value of 1, the weight parameter has a value of 2, and the color parameter has a value of red.

Optionally, in other implementations, the second function is different from the first function, and it may be understood that the identity of the second function is different from the identity of the first function. The identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function name of the second function. In this implementation, the function name of the first function is different from the function name of the second function. That is, in this implementation, the purpose of the upgrade is to upgrade the first function to another function (e.g., a second function) other than the first function. For example, the function name of the first function is the eat function, and the function name of the second function is the fly function. For another example, the function name of the first function is the eat function, and the function name of the second function includes the fly function and the eat function.

In the embodiment of the present application, the trigger condition for the manager to receive the function upgrade instruction is not specifically limited. Optionally, in some implementations, the receiving, by the manager, the function upgrade instruction includes: when the current time reaches the trigger time of a preset upgrading period, receiving a function upgrading instruction; or, the second response result does not meet the preset requirement, and a function upgrading instruction is received; the second response result is a response result obtained by transmitting a second request sent by the client to the compiled file of the first code by the first process running in the server and responding to the second request by the first process executing the compiled file of the first code, and the second request carries the identifier of the first function and the first variable information. The source of the manager to obtain the function upgrade instruction is not particularly limited. For example, the function upgrade instruction may be an instruction manually input to the manager by a user. As another example, the function upgrade instruction may be obtained by the manager through interaction with another device. In the implementation manner, the manager can obtain the function upgrading instruction under the condition that the upgrading condition is met, so that the manager can execute corresponding upgrading operation according to the actual upgrading requirement at the current moment. The length of the preset upgrade period is not particularly limited. For example, the user may set the length of the preset upgrade period according to the service scenario requirement, for example, the preset upgrade period is 1 day or 7 days. The second response result does not satisfy the preset requirement, which can be understood as that the performance of the first function in the first code associated with the first process does not satisfy the preset requirement. The preset requirement may be, but is not limited to: performance requirements of the operation, or user requirements.

S402, the manager generates a registry updating instruction according to the function upgrading instruction and sends the registry updating instruction to the client. Accordingly, the client receives a registry update instruction from the manager.

The registry updating instruction is generated by the manager according to a function updating instruction input by a user, the function updating instruction indicates that a first function in a first code associated with a first process running in the server is updated to a second function, the second function is different from the first function, the registry updating instruction is used for indicating that a first registry stored in the client is updated to a second registry, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry. Wherein the first variable information includes at least one first variable and a value of the at least one first variable, and the second variable information includes at least one second variable and a value of the at least one second variable. The first variable information is different from the second variable information, and it is understood that the first variable and the second variable are different, and the value of the first variable and the value of the second variable may be the same or different. For example, the first variable information includes that the first variable is weight, and the value of the first variable is 1; the second variable information includes a second variable that is speed, and the value of the second variable is 1. For another example, the first variable information includes a first variable of weight, and the value of the first variable is 2; the second variable information includes a second variable of food, and a value of the second variable is fish.

And executing the step S402, that is, the manager generates a registry update instruction according to the function upgrade instruction, and sends the registry update instruction to the client, so that the first registry stored in the client is updated to the second registry in the process that at least one function associated with the second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client, the first registry records the first variable information associated with the first function, and the second registry records the second variable information associated with the second function.

In this embodiment of the present application, a first process running in the server may be used to execute a first computing task, a second process running in the client may be used to execute a second computing task, and the first computing task and the second computing task may not be identical. Specifically, before the server and the client execute upgrade operation, a first process running in the server is used for realizing the calculation of a first calculation task by executing a first code comprising a first function; a second process running in the client is for performing a computation for a second computational task by executing code comprising at least one function for invoking the first function.

Optionally, before executing the above S402, the manager may further perform the following steps: sending a query message to the client, wherein the query message is used for querying whether second variable information is stored in a storage space which can be accessed by a second process running in the client; and receiving a query response message from the client, wherein the query response message is used for indicating that the storage space which can be accessed by a second process running in the client stores second variable information. The storage space accessible to the second process is not particularly limited. For example, the storage space accessible by the second process may be a segment of memory space in the client. For another example, the storage space accessible by the second process may be a segment of memory space in a device other than the client. The client communicates with the other device. Before executing S402, the above steps are performed, that is, the manager determines that the second variable information is variable information that can be accessed by a second process running in the client, so that, after the upgrade operation is executed, the client may successfully call a second function of the second code associated with the first process according to the accessed second variable information.

And S403, the manager generates indication information according to the function upgrading instruction and sends the indication information to the server. Accordingly, the server receives the indication information from the manager.

The indication information indicates a compiled file of second code, and the second code is code obtained by executing the operation indicated by the function upgrade instruction on the first code by the manager. In some implementations, the indication information is used to directly indicate a compiled file of the second code, and in such implementations, the indication information is a compiled file of the second code. It can be understood that, in this implementation manner, before the manager sends the indication information to the server, the following steps may also be performed: and compiling the second code to generate a compiled file of the second code. In other implementations, the indication information is used to indirectly indicate a compiled file of the second code, and in this implementation, the indication information includes the second code, and the indication information is specifically used to indicate that the compiled file of the second code is generated according to the second code.

And executing the step S403, that is, the manager generates the indication information according to the function upgrading instruction, and sends the indication information to the server, so that the compiled file of the first code is upgraded to the compiled file of the second code when the first process in the server is in the running state. In this implementation manner, by introducing the indication information generated by the manager, the compiled file of the first code is upgraded to the compiled file of the second code when the first process in the server is in the running state, so that interruption of the service associated with the first process running in the server can be avoided, that is, the service of the first process in the server can be upgraded without interrupting the service of the first process in the server.

In the embodiment of the present application, the type of the compiled file is not particularly limited. In some implementations, the compiled file may be, but is not limited to, a binary file, that is, the compiled file of the second code may be specifically a binary file of the second code, and the compiled file of the first code may be specifically a binary file of the second code.

Optionally, before the manager executes the above S403, the following steps may also be executed: and executing the operation indicated by the function upgrading instruction on the first code to generate a second code. Illustratively, the manager executes the upgrade operation indicated by the function upgrade instruction on the first code, and generates the second code, including: the manager executes the upgrading operation indicated by the function upgrading instruction on the first code associated with the third process in the manager, and generates a second code in the third process.

Optionally, before the manager executes the above S403, the following steps may be further performed: checking the second code, and determining that the second code meets the predefined code requirement, wherein the indication information comprises the second code, and the indication information specifically indicates that a compiled file of the second code is generated according to the second code; or detecting the compiled file of the second code, and determining that the compiled file of the second code meets the predefined compiled file requirement, wherein the indication information is the compiled file of the second code. The predefined code requirements include at least one of the following requirements: predefined variable type requirements, or predefined syntax requirements, etc. The predefined compiled file requirements include at least one of the following requirements: predefined format requirements, or predefined syntax requirements, etc. It is to be understood that, when the indication information is used to indicate the second code, the manager detects the second code; when the indication information is used to indicate the compiled file of the second code, the manager checks the compiled file of the second code. In the implementation manner, after the manager generates the indication information, the manager firstly checks the second code or the compiled file of the second code associated with the indication information, and sends the indication information to the server under the condition that the second code or the compiled file of the second code meets the corresponding requirement, so that the first process running in the server can successfully execute the compiled file of the second code, and the upgrading efficiency can be improved.

S404, in the process that at least one function in codes related to a second process running in the client calls the first function, the first registry is updated into a second registry according to the registry updating instruction.

In S404, the second process determines, according to the registry stored in the client, a function called by at least one function in the code associated with the second process. That is to say, before the client executes the above S404, the client determines, according to the first registry stored in the client, that a function called by at least one function associated with the second process running in the client is the first function. After the client executes the above S404, the client determines, according to the second registry stored in the client, that a function called by at least one function associated with the second process running in the client is the second function.

And executing the step S404, that is, in the process that at least one function in the code associated with the second process running in the client calls the first function associated with the first process running in the server, the client updates the first registry stored in the client to the second registry according to the registry update instruction. In this implementation manner, by introducing the registry update instruction generated by the manager, in the process that at least one function in the code associated with the second process running in the client calls the first function associated with the first process running in the server, the client is instructed to update the first registry to the second registry according to the registry update instruction, so that interruption of the service associated with the second process running in the client can be avoided, that is, the operation of upgrading the service of the second process running in the client can be completed without interrupting the service of the second process running in the client. It will be appreciated that the time it takes for the client to update the first registry to the second registry according to the registry update instruction is short (e.g., on the order of milliseconds). The client updates the first registry to the second registry according to the registry update instruction, and for example, table 1 below shows the first registry, and table 2 shows the second registry. It should be understood that tables 1 and 2 are only illustrative and do not constitute any limitation to the first registry and the second registry described in the embodiments of the present application.

TABLE 1

TABLE 2

It is to be understood that the variable 1 shown in the above table 1 is one example of the first variable, and the value 1 is one example of the value of the first variable. The variable 2 shown in table 2 above is an example of the second variable, and the value 2 is an example of the value of the second variable.

In this embodiment of the application, before the upgrade operation is performed, the second process running in the client may call an execution result of the first function associated with the first process running in the server. That is, before executing the above S404, the client may further execute the following steps: generating first sequence data according to a first registry and a second request generated by a second process running in the client, wherein the first sequence data comprises the second request, the second request carries an identifier of a first function and first variable information, and the first variable information comprises a first variable and a value of the first variable; sending the first sequence data to the server, so that a compiled file of the first code is executed through a first process running in the server to respond to the second request; receiving second sequence data from the server, wherein the second sequence data comprise a second response result, the second response result is a result obtained by transmitting the first variable and the value of the first variable into the compiled file of the first code, and the compiled file of the first code is executed through the first process to respond to the second request, and the second response result does not meet the preset requirement; and analyzing the second sequence data to obtain a second response result, and transmitting the second response result into the second process, so that the second process successfully calls the first function associated with the first process. In the foregoing implementation manner, before the upgrade, the execution result of the first function does not meet the preset requirement, so that the upgrade operation needs to be executed on the first function in the first code associated with the first process in the server.

In the embodiment of the present application, the server and the client may communicate by using RPC. In this implementation, any sequence data involved in this embodiment may further include a preset encapsulation protocol. The preset encapsulation protocol comprises a network transmission protocol and an RPC message protocol. The network transmission protocol is TCP/IP or UDP protocol. The RPC message protocol includes rules for performing serialized encapsulation of data to be transmitted, and rules for performing deserialization of the serialized encapsulated data. The serialization encapsulation is to encapsulate data to be sent into data in a preset format, and the deserialization of the serialized encapsulated data is to restore the data in the preset format into the data to be sent. Illustratively, the first sequence data includes a second request and a preset encapsulation protocol, and the client encapsulates the second request by the preset encapsulation protocol to generate the first sequence data. Correspondingly, after receiving the first sequence data, the server decapsulates the first sequence data according to a preset encapsulation protocol to obtain a second request.

In this embodiment of the application, after the upgrade operation is performed, the second process running in the client may call an execution result of the second function associated with the first process running in the server. That is, optionally, after the client executes the above S404, the following steps may also be executed: generating third sequence data according to a second registry and a first request generated by a second process running in the client, wherein the third sequence data comprises the first request, the first request carries second variable information and an identifier of a second function, and the second variable information comprises a second variable and a value of the second variable; sending third sequence data to the server, so that the first request is responded by a first process running in the server to execute the compiled file of the second code; receiving fourth sequence data from the server, wherein the fourth sequence data comprises a first response result, the first response result is a result obtained by transmitting a second variable and a value of the second variable into a compiled file of the second code, and the first response result meets a preset requirement by executing the compiled file of the second code through a first process to respond to the first request; and analyzing the fourth sequence data to obtain a first response result, and transmitting the first response result into the second process, so that the second process successfully calls a second function associated with the first process. In the implementation manner, after the upgrading, the execution result of the second function meets the preset requirement. It should be noted that, in the embodiment of the present application, the number of upgrading operations is not specifically limited. For example, after one or more upgrade operations may be performed, a call result associated with a first process running in the first process in the function call server may meet a preset requirement.

Optionally, before the client executes the above S404, the following steps may also be executed: receiving a query message sent by a manager, wherein the query message is used for querying whether second variable information is stored in a storage space accessible by a second process running in a client; and sending a query response message to the manager, wherein the query response message is used for indicating that the storage space which can be accessed by a second process running in the client stores second variable information.

S405, the server side obtains the compiled file of the second code according to the indication information.

And the server acquires the compiling file mode of the second code according to the indication information and is specifically associated with the content indicated by the indication information. Two implementation manners of the server obtaining the compiled file of the second code according to the indication information are respectively described below.

The implementation mode is as follows:

in the first implementation manner, the indication information is a compiled file of the second code. In this implementation, the compiled file of the second code is generated by the manager, and the server may receive the compiled file of the second code from the manager.

The implementation mode two is as follows:

in a second implementation, the indication information includes a second code, and the indication information specifically indicates that a compiled file of the second code is generated according to the second code. In this implementation manner, the obtaining, by the server, the compiled file of the second code according to the indication information includes: and compiling the second code to generate a compiled file of the second code. In this implementation, the compiled file of the second code is generated by the server.

S406, the server side upgrades the compiled file of the first code into the compiled file of the second code under the condition that the first process is in the running state, so that the first function is upgraded into the second function.

And S406 is executed, that is, when the first process is in the running state, the server dynamically loads the compiled file of the second code to the first process in the running state, so as to upgrade the compiled file of the first code to the compiled file of the second code, so that the first process after executing the dynamic loading runs the compiled file of the second code. The time consumed by the server to dynamically load the compiled file of the second code into the first process in the running state is short (e.g., milliseconds). The server executes the above dynamic loading process, which may also be understood as a process in which the server executes just-in-time compilation (just-in-time compilation refers to a process in which compilation is performed during running of a process), that is, a process in which the server modifies a compiled file of a first code associated with a first process into a compiled file of a second code when the server runs the first process.

Next, a method is described in which, when a first process is in a running state, a server dynamically loads a compiled file of a second code to the first process, so as to upgrade the compiled file of the first code to a compiled file of the second code. In some implementations, the identifier of the first function is the same as the identifier of the second function, and the first variable information is different from the second variable information, and the identifier of the first function is used to indicate a function name of the first function. In this implementation manner, the server performs the above S406, which includes: according to the identification of the first function, determining the address of a compiled file storing the first code in the storage space of the server as a first address; and updating the content stored in the first address into a compiled file of the second code. Therefore, the server dynamically loads the compiled file of the second code to the first process in the running state under the condition that the first process is in the running state, so as to upgrade the compiled file of the first code to the compiled file of the second code. In this implementation, the purpose of the upgrade is to upgrade the variables of a function. For example, the first function is an eat function, and the variable included in the first variable information is food; the second function is an eat function, and the second variable information comprises variables of food and speed. Optionally, in other implementations, the identity of the first function is different from the identity of the second function. In this implementation, the above S406 is executed, that is, the server performs the following steps: creating a second address for the function corresponding to the identifier of the second function in the storage space of the server; and storing the compiled file of the second code to the second address. In this implementation, the second function may be understood as a newly created function, and therefore a corresponding function address (i.e., the second address) needs to be allocated to the second function in the storage space of the server. In this implementation, the purpose of upgrading is to upgrade the kind of function. For example, the first function is an eat function, the second function is a fly function, and the body of the function indicated by the eat function is different from the body of the function indicated by the fly function. In some implementation manners, the storage space of the server is a memory space of the server, and the first address and the second address are partial addresses in the memory space of the server.

Before the upgrade operation is performed, a first process running in the server may receive a call request sent by a second process running in the client. That is to say, optionally, in other implementation manners, before the server executes the above S406, the following steps may also be executed: receiving first sequence data sent by a client, wherein the first sequence data comprise a second request, variable information carried by the second request is first variable information associated with a first function recorded in a first registry stored in the client, the first variable information comprises a first variable and a value of the first variable, and the second request is a request generated by a second process running in the client; analyzing the first sequence data to obtain a second request, transmitting the first variable and the value of the first variable into a compiled file of the first code, executing the compiled file of the first code through a first process to respond to the second request to obtain a second response result, wherein the second response result does not meet the preset requirement; and sending second sequence data to the client to enable the client to transmit the first response result into a second process, wherein the second sequence data comprises a second response result. In the implementation manner, before the upgrade, the execution result of the first function does not meet the preset requirement, so that the upgrade operation is required to be executed on the first function in the first code associated with the first process in the server.

After the upgrade operation is performed, a first process running in the server may receive a call request sent by a second process running in the client. That is, optionally, in another implementation manner, after the server performs the above S406, the following steps may also be performed: receiving third sequence data sent by a client, wherein the third sequence data comprise a first request, variable information carried by the first request is second variable information associated with a second function recorded in a second registry stored in the client, the second variable information comprises a second variable and a value of the second variable, and the first request is a request generated by a second process running in the client; analyzing the third sequence data to obtain a first request, transmitting a second variable and a value of the second variable into a compiled file of a second code, executing the compiled file of the second code through a first process to respond to the first request to obtain a first response result, wherein the first response result meets a preset requirement; and sending fourth sequence data to the client so that the client transmits the first response result into the second process, wherein the fourth sequence data comprises the first response result. In the implementation manner, after the upgrading, the execution result of the first function meets the preset requirement. It should be noted that, in the embodiment of the present application, the number of upgrading operations is not specifically limited. For example, after one or more upgrade operations are performed, at least one function in the code associated with the second process running in the client calls the call result associated with the first process running in the server, and the call result meets the preset requirement.

In the embodiment of the present application, the execution sequence of executing the above S402 and S403 is not particularly limited. That is, after the execution of the above S401, the above S402 may be executed first, and then the above S403 may be executed. Alternatively, after the execution of S401, S403 may be executed first, and then S402 may be executed. In general, the performance of the server is higher than that of the client, and in practical applications, after S401 is executed, S402 may be executed first, and then S403 may be executed.

In the embodiment of the present application, the execution sequence of executing the above S404 and the above S406 is not particularly limited. In some implementations, the S404 and the S406 are performed at the same time and are performed at another time. In this implementation, the step of updating the registry performed by the client and the step of upgrading the compiled file performed by the server are performed synchronously. Optionally, in other implementation manners, the client performs the S404 and the server performs the S406 without performing synchronously. For example, the client performs the step S404 first, and the server performs the step S406 again. For another example, the server performs the above S406 first, and the client performs the above S404 again. In this implementation of asynchronous execution, the upgrade operations of the client and the server for the first function are not completed at the same time. Based on this, under the condition that the client executes the registry updating operation and the server does not execute the upgrading operation of the compiled file, if the client calls the function corresponding to the server according to the updated second registry, the server may send an error notification to the client, and instruct the client to call the function corresponding to the server again according to the second registry after a period of time (e.g., 10 milliseconds).

In an embodiment of the application, code is maintained by the manager, the code including at least a first code and a second code. And the manager determines to generate a registration updating instruction and indication information according to the received function upgrading instruction, sends the registration updating instruction to the client and sends the indication information to the server. The function upgrading instruction instructs to upgrade a first function in first codes associated with a first process running in the server to a second function. The register updating instruction sent by the manager to the client instructs the client to update the first registry to the second registry so as to complete the upgrading operation indicated by the function upgrading instruction in the client. And the indication information sent to the server by the manager indicates the server to upgrade the compiled file of the first code into the compiled file of the second code so as to upgrade the first function into the second function. In this implementation manner, the server does not need a first process running in the server to modify the first code into a second code, and only needs to upgrade a compiled file of the first code associated with the first process into a compiled file of the second code according to indication information sent by the manager, where the process of upgrading the compiled file by the server is a just-in-time compilation process (just-in-time compilation refers to a process of compiling during running of a process), and the just-in-time compilation process does not need to interrupt the first process running in the server. That is, in the above-described upgrading method, it is not necessary to interrupt the second process running in the client, nor the first process running in the server. In conclusion, the method completes the upgrading of the service under the condition of not interrupting the service.

Next, another upgrading method provided by the embodiment of the present application is described with reference to fig. 5. It should be understood that the example of fig. 5 is merely to assist those skilled in the art in understanding the embodiments of the present application, and is not intended to limit the embodiments of the application to the specific values or specific scenarios illustrated. It will be apparent to those skilled in the art that various equivalent modifications or variations are possible in light of the example of fig. 5 given below, and such modifications and variations also fall within the scope of the embodiments of the present application. It is understood that the upgrade method shown in fig. 5 is a specific example of the upgrade method shown in fig. 4 described above. Specifically, the upgrade method described in fig. 5 is that the identifier of the first function and the identifier of the second function described in fig. 4 are the same, and the identifier of the first function is used to indicate the eat function; and the manager in fig. 4 sends the second code (i.e., the source code of the updated eat function described in fig. 5) to the server as an example.

Fig. 5 is a schematic diagram of another upgrading method provided in an embodiment of the present application. The client, manager and server shown in fig. 5 may be the client 110, server 120 and manager 130 in the application scenario shown in fig. 1. Wherein, the client 110, the server 120 and the manager 130 may be as shown in the structure shown in fig. 2. As shown in fig. 5, the upgrade method shown in fig. 5 includes S501 to S509. Optionally, a calling method, i.e., S510 to S514, may be further executed after the upgrade method is executed. Next, S501 to S514 will be described in detail.

S501, determining an upgrading instruction by a developer according to a preset parameter set, wherein the upgrading instruction comprises upgrading information of the eat function associated with the process 2, and the process 2 is a process operated in the server.

The condition for triggering the developer to execute the above S501 is not particularly limited. In some implementations, the foregoing S501 is executed, that is, in a case that the preset condition is not met, the developer determines the upgrade instruction according to the preset parameter set. The condition that the process 2 does not meet the preset condition means that the performance of the process 2 running in the server does not meet the preset performance requirement. The predetermined performance requirements are not particularly limited. For example, the preset performance requirements may be determined according to user requirements. For example, the user requirement indicates that all methods associated with the process 2 are executed within 2 minutes, and in the actual test, if the time required for the process 2 to execute all the methods is 5 minutes, it is considered that the preset condition is not satisfied. Optionally, in another implementation manner, the foregoing S501 is executed, that is, the preset period is reached, and the developer determines the upgrade instruction according to the preset parameter set. The preset period can be determined according to the requirements of the actual application scene. For example, the preset period may be one week or one month, etc. Illustratively, after a preset week, the developer determines an upgrade order according to a preset parameter set.

The preset parameter set is also called a preset namespace. Wherein the preset parameter set comprises a plurality of parameters and values of the plurality of parameters. The number and type of the parameters included in the preset parameter set are not particularly limited. The developer can set a plurality of parameters included in the preset parameter set and values of the parameters according to actual application conditions. The location where the preset parameter set is stored is not particularly limited. For example, the preset parameter set may be stored in a storage space of any one of the client, the manager, or the server. In this embodiment of the present application, the preset parameter set in S501 may be specifically expressed as { food: fish, speed:1, weight: food, speed, weight, color; the food parameter has a value of fish, the speed parameter has a value of 1, the weight parameter has a value of 2, and the color parameter has a value of red.

In some implementations, in the process of executing S501, the source code of the eat function associated with the current process 2 may be as follows:

eat(set):

a = set.food; # the food parameter is taken from the preset parameter set

c＝20；

return a+c.

In the above implementation, the food parameter is indicated by the preset parameter set.

The upgrade instruction includes the source code of the eat function indicated by the upgrade information of the eat function associated with the process 2, which may be as follows:

eat(set):

a = set.food; # the food parameter is taken from the preset parameter set

Speed, b = set; # fetching speed parameters from a Preset parameter set

c＝20；

return a*b+c.

Specifically, the update information of the eat function associated with the process 2 indicates that the parameters of the eat function associated with the process 2 running on the server are updated from the "food parameter" to the "food parameter" and the "speed parameter", and the return value of the eat function is updated from "a + c" to "a + b + c". In the implementation manner, the food parameter and the speed parameter are indicated by the preset parameter set.

Optionally, in other implementations, eat (set) shown in the source code may also be replaced with eat (). In such implementations, eat () may implicitly indicate the food parameter, or eat () may implicitly indicate the food parameter and the speed parameter.

S502, the developer inputs an upgrading instruction to the manager.

In the embodiment of the present application, a process 3 runs in the manager, and the source code associated with the process 3 includes the source code associated with the eat function. The developer inputs the upgrade instruction to the manager, which means that the developer inputs the upgrade instruction to the code associated with the process 3 in the manager. In some implementations, a developer may input upgrade instructions to the code associated with process 3 through a compiler provided by the manager. It is understood that the manager may be in a running state or an interruption state before executing S502, which is not particularly limited. At the start of execution of S502, the manager is in an operating state.

S503, the manager acquires an upgrade instruction input by the developer to update the source code of the eat function associated with the process 3, and acquires the updated source code of the eat function.

After the step S530 is executed, the source code of the updated eat function is obtained, and then the source code of the updated eat function associated with the process 3 may be as follows:

eat(set):

a = set.food; # the food parameter is taken from the preset parameter set

Speed, b = set; # obtaining speed parameters from the Preset parameter set

c＝20；

return a*b+c.

Optionally, after executing the above S503, the manager may further check the source code of the updated eat function to determine that the source code of the updated eat function is correct, that is, there is no syntax error, no variable type error, and the like in the source code of the updated eat function.

S504, the manager interacts with the client, the manager confirms that the process 1 running in the client can access the function parameter indicated by the source code of the updated eat function, and the process 1 is a process for calling the process 2.

The method includes the following steps that the manager interacts with the client, and the manager confirms that a process 1 running in the client can access function parameters indicated by source codes of updated eat functions, and includes: the manager sends a query message after serialization and encapsulation to the client, wherein the query message is used for querying whether parameters of a process 1 running in the client include function parameters indicated by source codes of the updated eat function or not; the client carries out deserialization processing on the received query message after the serialization encapsulation to obtain the query message; the client determines that the preset parameter set accessible to the client includes the function parameter indicated by the source code of the updated eat function queried by the query message by comparing the preset parameter set accessible to the client with the function parameter indicated by the source code of the updated eat function queried by the query message.

And S505, the manager sends the name of the eat function and the updated source code of the eat function to the server. Accordingly, the server receives the eat function name and the source code of the updated eat function from the manager.

The manner in which the manager sends the eat function name and the updated source code of the eat function to the server is not particularly limited. For example, the manager may encapsulate the eat function name and the source code of the updated eat function into a data packet, and then send the encapsulated data packet to the server. For another example, the manager may encapsulate the eat function name and the updated source code of the eat function into a data message, and then the manager sends the data message to the server.

S506, the server compiles the updated source code of the eat function to obtain a compiling result of the updated source code of the eat function.

The compiling the updated source code of the eat function by the server side to obtain the compiling result of the updated source code of the eat function comprises the following steps: and dynamically loading the updated source code of the eat function by the process 2 running in the server, and compiling the updated source code of the eat function to obtain a compiling result of the updated source code of the eat function. It can be understood that the compilation result of the source code of the updated eat function is a binary file that can be executed by the server, and the function of the updated eat function indicated by the binary file is the same as the function of the source code of the updated eat function. That is, the compilation result of the updated eat function source code is also called as a binary file of the updated eat function source code.

In the above implementation manner, the process 2 is to dynamically load the source code of the updated eat function, and compile the source code of the updated eat function to obtain a compilation result. That is, process 2 is interrupt-free when the above steps are performed. In other words, the process 2 is always in operation during the execution of the above steps.

In this embodiment of the application, after the foregoing S506 is executed, parameters of the eat function recorded in the client registry need to be updated according to the function parameters indicated by the source code of the eat function after the update, and contents stored in a memory space 2 in a memory 2 of the server need to be updated according to a compilation result, where the memory space 2 is a function address allocated to the eat function. The execution sequence of the step of updating the client registry and the step of updating the content stored in the memory space 2 is not particularly limited. That is, the step of updating the client registry may be performed after the step of performing S506, and then the step of updating the content stored in the memory space 2 may be performed. Optionally, after executing the above S506, the step of updating the content stored in the memory space 2 is executed first, and then the step of updating the client registry is executed. Next, a description will be given by taking, as an example, a step of updating the client registry after S506 is executed, and then a step of updating the content stored in the memory space 2 is executed.

S507, the manager sends a registry updating instruction to the client. Accordingly, the client receives a registry update instruction from the manager.

And the registry updating instruction is used for indicating that the parameters associated with the eat function in the client registry are updated to the function parameters indicated by the source code of the updated eat function. Specifically, the function parameters indicated by the source code of the updated eat function include a food parameter and a speed parameter.

The client registry is used for recording functions related to the client process and the association relation between parameters corresponding to the functions.

In some implementations, the client registry is a registry of process 1 running in the client. In this implementation, the client registry is in a one-to-one correspondence with process 1. The identity of the client registry is used to uniquely indicate process 1. The client registry is used for recording the association relationship between the functions associated with the process 1 and the parameters corresponding to the functions associated with the process 1. Before executing the above S507, the function associated with the process 1 recorded in the client registry is an eat function, and the parameter associated with the eat function is a food parameter. For example, in this implementation, the client registry may be as shown in table 3:

TABLE 3

Optionally, in another implementation manner, the client registry is a registry of all processes running in the client, and all processes running in the client include process 1 and process #1. In this implementation, the client registry and the processes are in a one-to-many relationship, so that the processes corresponding to the functions can be indicated by the process identification fields in the client registry. Before executing the above S508, the function associated with the process 1 recorded in the client registry is an eat function, and the parameter associated with the eat function is a food parameter; the function associated with the recorded process #1 is a fly function, and the parameters associated with the eat function are a food parameter and a bird parameter. For example, in this implementation, the client registry may be as shown in table 4:

TABLE 4

And S508, the client updates the client registry according to the registry updating command to obtain the updated client registry.

In the embodiment of the present application, the function parameters indicated by the source code of the updated eat function indicated by the registry update instruction include a food parameter and a speed parameter. The method for updating the client registry by the client according to the registry updating instruction to obtain the updated client registry comprises the following steps: the client determines the position of a parameter corresponding to the eat function name in the registry as a position 1 according to the registry updating instruction and the eat function name; the client updates the content at location 1 to the food parameter and speed parameter.

For example, taking the client registry before updating as the above table 3 as an example, the client registry after performing the above S508 may be as shown in the following table 5:

TABLE 5

For example, taking the client registry before updating as the table 4 above as an example, the client registry after updating after executing the above S509 may be as shown in the following table 6:

TABLE 6

S509, the server updates the content stored in the memory space 2 in the memory 2 of the server according to the updated compiled result of the source code of the eat function, where the memory space 2 is a function address allocated to the eat function.

The memory space 2 is a partial space of the memory 2. The memory space 2 is a function address allocated to the eat function, that is, the memory space 2 at least stores the following contents: compiling results of source codes of the eat function and parameters corresponding to the eat function.

The updating, by the server, of the content stored in the memory space 2 in the memory 2 of the server according to the updated compilation result of the source code of the eat function includes: the server side determines a memory space 2 in a memory 2 of the server side as a function address of the eat function according to the eat function name; and the server updates the source code stored in the memory space 2 according to the updated compilation result of the source code of the eat function. Specifically, in the update process, the server updates the food parameter of the eat function stored in the memory space 2 to the food parameter and speed parameter indicated by the compiling result of the source code of the updated eat function.

In practical applications, the performance of the server is generally better than that of the client. That is, the content set in the server can be successfully modified in general, but the content set in the client cannot be successfully modified (for example, the modification fails due to a crash of the client when the client modifies). In the above implementation manner, after executing S506, the step of updating the client registry is executed first, and then the step of updating the content stored in the memory space 2 is executed. Therefore, the modification risk can be reduced, and the parameters corresponding to the eat function recorded in the client registry are ensured to be consistent with the parameters corresponding to the eat function recorded in the memory space 2 corresponding to the running process 2 in the server.

After the above S501 to S509 are executed, the purpose of upgrading the parameter of the eat function associated with the process 2 is achieved without interrupting the process 1 and the process 2.

In the upgrading process described in the embodiment of the present application, when a function associated with a process 2 running in a server and called by a process 1 running in a client needs to be upgraded, a server developer upgrades a source code associated with a process 3 in a manager, so that the process 2 in the server and the process 1 in the client do not interrupt running, and the function associated with the process 2 in the server 120 is upgraded. Specifically, after upgrading the source code of the eat function associated with the process 3 according to the upgrade instruction, the manager sends the source code of the upgraded eat function to the server. And simultaneously, the manager instructs the client to update the parameters of the eat function recorded in the client registry according to the parameters of the eat function indicated by the source code of the updated eat function, so as to obtain the updated client registry. After the server receives the upgraded source code, the server updates the compiling result of the source code associated with the process 2 running in the server in a dynamic loading mode. In the upgrading process, the problem that in the traditional upgrading process, developers need to rewrite source codes of the eat functions respectively compiled in the process 1 and the process 2 according to upgrading requirements under the condition that the process 1 and the process 2 are interrupted is avoided, so that the eat functions related to the process 2 are upgraded.

Optionally, after executing the above S501 to S509, the process 1 running in the client may further continue to call the eat function associated with the process 2 running in the server. In this implementation, the eat function associated with the process 2 is an eat function updated according to the method described in the foregoing S501 to S509. Next, after the upgrade operations described in the above S501 to S509 are performed, the method for calling the eat function associated with the process 2 running in the server is continued to be called by the process 1 running in the client, which is described in detail in conjunction with S510 to S514.

S510, the client side obtains a calling request sent by a process 1 running in the client side, and generates serialized data 1 according to the calling request and the updated client side registry.

The call request is used for requesting to call the eat function associated with the process 2 running in the server. The call request includes the eat function name and the identity of process 1.

Executing the above S510, that is, the client acquires the call request sent by the process 1 running in the client, and generates the serialized data 1 according to the call request and the updated client registry, including: the client determines a parameter corresponding to an eat function requested to be called by the calling request according to the calling request and the updated client registry; the client determines the value of the parameter corresponding to the eat function requested to be called by the calling request according to the preset parameter set and the parameter corresponding to the eat function requested to be called by the calling request; and the client encapsulates the eat function name and the value of the parameter corresponding to the eat function requested to be called by the calling request according to a preset encapsulation protocol to generate the serialized data 1. Specifically, the parameters corresponding to the eat function requested to be called by the call request include a food parameter and a speed parameter, the value of the food parameter is fish, and the value of the speed parameter is 1. The above encapsulation process is specifically used for encapsulating eat (data), data = { food: fish, speed:1}.

The preset packaging protocol comprises a network transmission protocol and an RPC message protocol. The network transmission protocol is TCP/IP or UDP protocol. The RPC message protocol includes rules for performing serialized encapsulation of data to be transmitted, and rules for performing deserialization of the serialized encapsulated data. The serialization encapsulation is to encapsulate data to be sent into data in a preset format, and the deserialization of the serialized encapsulated data is to restore the data in the preset format into the data to be sent.

S511, the client sends the serialized data 1 to the server. Accordingly, the server receives serialized data 1 from the client.

The network transmission protocol used by the client to send the serialized data 1 to the server in S512 may be the same as the network transmission protocol used by the predetermined encapsulation protocol in S511.

S512, the server side obtains an execution result corresponding to the call request according to the serialized data 1; and encapsulating the execution result according to a preset encapsulation protocol to obtain serialized data 2.

The server obtains an execution result corresponding to the call request according to the serialized data 1, and the method comprises the following steps: the server decapsulates the serialized data 2 according to a preset encapsulation protocol to obtain the name of the eat function and the value of a parameter corresponding to the eat function requested to be called by the calling request; the server side determines the eat function as a function related to the process 1 according to the eat function name, and a function address allocated to the eat function is a memory space 2; the server transmits the value of the parameter corresponding to the eat function requested to be called by the calling request into the compiling result of the source code of the updated eat function stored in the memory space 2; and the process 2 running in the server side calculates according to the value of the parameter corresponding to the eat function requested to be called by the calling request and the compiling result of the source code of the updated eat function so as to obtain the execution result corresponding to the calling request.

The network transmission protocol used by the encapsulation protocol preset in S512 may be the same as the network transmission protocol used by the encapsulation protocol preset in S510.

S513, the server sends the serialized data 2 to the client. Accordingly, the client receives the serialized data 2 from the server.

In S513, the network transmission protocol used by the client to send the serialized data 2 to the server is the same as the network transmission protocol used by the pre-set encapsulation protocol in S512.

And S514, the client obtains an execution result according to the serialized data 2, and transmits the execution result to the process 1 running in the client 1.

It should be noted that, in the embodiment of the present application, in the process of executing the foregoing S501 to S514, the process 1 in the client and the process 2 in the server are always in the running state, that is, in the process of upgrading the parameter of the eat function associated with the process 2, the process 1 and the process 2 are uninterrupted. The process 3 in the manager is in a running state in the process of upgrading the eat function associated with the process 2. Optionally, before and after the eat function associated with the process 2 is upgraded, the process 3 may be in an interrupted state, so as to save network resource overhead.

Executing the above S511 to S514, that is, after the eat function associated with the process 2 is upgraded, the process 1 running in the client continues to call the eat function associated with the process 2 running in the server.

It should be understood that the upgrade method and the call method provided by the embodiment of the present application shown in fig. 5 are only illustrative and do not constitute any limitation to the upgrade method provided by the embodiment of the present application. The above-mentioned upgrade method provided in the embodiment of the present application is described in fig. 5 by taking the purpose of upgrading the parameter of the eat function associated with the process 2 as an example. Optionally, in another implementation manner, the function associated with the process 2 may also be upgraded, that is, the purpose of the upgrade is to enable the process 2 to provide the service associated with the newly added function. For example, the function associated with the process 2 in fig. 5 is an eat function, and the purpose of the upgrade may be to upgrade the function associated with the process 2 from the "eat function" to the "eat function" and the "swim function", where the services provided by the two functions of the swim function and the eat function are different.

In the calling process described in the embodiment of the present application, when the process 1 running in the client calls the eat function associated with the process 2, the client can automatically determine the parameter and the value of the corresponding parameter of the eat function associated with the process 2 to be called currently according to the preset parameter set, the updated client registry, and the name of the eat function included in the call request sent by the process 1, and the parameter of the eat function automatically determined by the client is the parameter associated with the eat function upgraded in the steps S501 to S509.

In the above, an application scenario and an upgrade method to which the upgrade method provided by the present application is applied are described in detail with reference to fig. 1 to 5. The upgrade apparatus, device and system provided by the present application will be described with reference to fig. 6 to 8. It should be understood that the above upgrading method corresponds to the below upgrading apparatus, electronic device, and upgrading system. Reference may be made to the description relating to the method embodiments above, which are not described in detail below.

Fig. 6 is a schematic structural diagram of an upgrading apparatus provided in an embodiment of the present application. As shown in fig. 6, the apparatus includes a transceiver 601 and a processing unit 602,

in the first implementation manner, the first control unit is provided with a first control unit,

in one implementation, the upgrade apparatus shown in fig. 6 is applied to a manager through which a code is maintained. In this implementation, the role of the transceiving unit 601 and the role of the processing unit 602 are described below.

The transceiver 601 is configured to receive a function upgrade instruction, where the function upgrade instruction instructs to upgrade a first function in a first code associated with a first process running in a server to a second function, where the second function is different from the first function; the processing unit 602 is configured to generate a registry update instruction according to the function upgrade instruction; the transceiver 601 is further configured to: sending the registry updating instruction to a client, so that a first registry stored in the client is updated to a second registry in the process that at least one function in codes associated with a second process running in the client calls the first function; the second process determines a function called by at least one function in codes associated with the second process according to a registry stored in the client, wherein first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry; the processing unit 602 is further configured to: generating indication information according to the function upgrading instruction; the transceiver 601 is further configured to: sending the indication information to the server, so that the server upgrades the compiled file of the first code into the compiled file of a second code, and upgrades the first function into the second function; wherein the indication information indicates a compiled file of the second code, the code including at least the first code and the second code, the second code being a code obtained by performing the operation indicated by the upgrade instruction on the first code.

Optionally, in some implementations, the identifier of the first function is the same as the identifier of the second function, and the first variable information is different from the second variable information; or the identification of the first function is different from the identification of the second function; wherein the identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function name of the second function.

Optionally, in other implementations, the processing unit 602 is further configured to: and executing the operation indicated by the upgrading instruction on the first code to generate the second code.

Optionally, in another implementation manner, the indication information is a compiled file of the second code, and the processing unit 602 is further configured to: and compiling the second code to generate a compiled file of the second code.

Optionally, in another implementation manner, the indication information includes the second code, and the indication information specifically indicates that a compiled file of the second code is generated according to the second code.

Optionally, in another implementation manner, the transceiver 601 is further configured to: sending a query message to the client, wherein the query message is used for querying whether the second variable information is stored in a storage space accessible to the second process running in the client; receiving a query response message from the client, wherein the query response message is used for indicating a storage space accessible to the second process running in the client to store the second variable information.

Optionally, in another implementation manner, the transceiver 601 is further configured to: when the current time reaches the trigger time of a preset upgrading period, receiving the function upgrading instruction; or, the second response result does not meet the preset requirement, and the function upgrading instruction is received; the second response result is obtained by the first process running in the server side transmitting a second request sent by the client side into the compiled file of the first code and by the first process executing the compiled file of the first code to respond to the second request, and the second request carries the identifier of the first function and the first variable information.

Optionally, in other implementations, the processing unit 602 is further configured to: checking the second code, and determining that the second code meets predefined code requirements, wherein the indication information includes the second code, and the indication information specifically indicates that a compiled file of the second code is generated according to the second code; or detecting the compiled file of the second code, and determining that the compiled file of the second code meets the predefined compiled file requirement, wherein the indication information is the compiled file of the second code.

In the second implementation mode, the first implementation mode is,

in the second implementation, the upgrade apparatus shown in fig. 6 is applied to a server, and in this implementation, the role of the transceiver 601 and the role of the processing unit 602 are described below.

The transceiver 601 is configured to receive indication information from a manager, where the indication information indicates a compiled file of a second code, where the second code is obtained by the manager performing an operation indicated by a function upgrade instruction on a first function in a first code associated with a first process running in the server, and the function upgrade instruction indicates to upgrade the first function in the first code to a second function, where the second function is different from the first function; the processing unit 602 is configured to obtain a compiled file of the second code according to the indication information; the processing unit 602 is further configured to: and upgrading the compiled file of the first code to the compiled file of the second code under the condition that the first process is in a running state, so as to upgrade the first function to the second function.

Optionally, in some implementations, the indication information is a compiled file of the second code.

Optionally, in another implementation manner, the indication information includes the second code, where the indication information specifically indicates that a compiled file of the second code is generated according to the second code, and the processing unit 602 is further configured to: and compiling the second code to generate a compiled file of the second code.

Optionally, in another implementation manner, the identifier of the first function is the same as the identifier of the second function, and the first variable information is different from the second variable information, where the identifier of the first function is used to indicate a function name of the first function, and the processing unit 602 is further configured to: determining the address of a compiled file storing the first code in the storage space of the server as a first address according to the identifier of the first function; and updating the content stored in the first address into a compiled file of the second code.

Optionally, in other implementations, the identifier of the first function is different from the identifier of the second function, and the processing unit 602 is further configured to: creating a second address for the function corresponding to the identifier of the second function in the storage space of the server; storing the compiled file of the second code to the second address.

Optionally, in another implementation manner, the transceiver 601 is further configured to: receiving first sequence data sent by a client, wherein the first sequence data comprise a second request, variable information carried by the second request is first variable information associated with the first function recorded in a first registry stored in the client, the first variable information comprises a first variable and a value of the first variable, and the second request is a request generated by a second process running in the client; the processing unit 602 is further configured to: analyzing the first sequence data to obtain the second request, transmitting the first variable and the value of the first variable into a compiled file of the first code, and executing the compiled file of the first code through the first process to respond to the second request to obtain a second response result, wherein the second response result does not meet preset requirements; the transceiver 601 is further configured to: and sending second sequence data to the client to enable the client to transmit the first response result into the second process, wherein the second sequence data comprise the second response result.

Optionally, in another implementation manner, the transceiver 601 is further configured to: receiving third sequence data sent by a client, wherein the third sequence data comprises a first request, variable information carried by the first request is second variable information associated with the second function recorded in a second registry stored in the client, the second variable information comprises a second variable and a value of the second variable, and the first request is a request generated by a second process running in the client; the processing unit 602 is further configured to: analyzing the third sequence data to obtain the first request, transmitting the second variable and the value of the second variable into a compiled file of the second code, and executing the compiled file of the second code through the first process to respond to the first request to obtain a first response result, wherein the first response result meets a preset requirement; the transceiver 601 is further configured to: and sending fourth sequence data to the client to enable the client to transmit the first response result into the second process, wherein the fourth sequence data comprises the first response result.

Optionally, in another implementation manner, the function upgrade instruction is received by the manager under any one of the following conditions: the current moment reaches the trigger moment of the preset upgrading period; or a second response result does not meet preset requirements, where the second response result is a response result obtained by the first process running in the server terminal transmitting a second request sent by a client to a compiled file of the first code and responding to the second request by the first process executing the compiled file of the first code, the second request carries first variable information associated with the first function recorded in a first registry stored in the client terminal and an identifier of the first function, and the first variable information includes a first variable and a value of the first variable.

In the third implementation mode, the first control unit is provided with a first control unit,

in the third implementation manner, the upgrading apparatus shown in fig. 6 is applied to a client. Next, the role of the transceiving unit 601 and the role of the processing unit 602 in this implementation will be described.

The transceiver unit 601 is configured to receive a registry update instruction from a manager, where the registry update instruction is generated by the manager according to a function upgrade instruction, the function upgrade instruction indicates that a first function in a first code associated with a first process running in a server is upgraded to a second function, the second function is different from the first function, the registry update instruction is used to indicate that a first registry stored in the client is updated to a second registry, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry; the processing unit 602 is configured to: and updating the first registry to a second registry according to the registry updating instruction in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client.

Optionally, in some implementations, the identifier of the first function is the same as the identifier of the second function, and the first variable information is different from the second variable information; or the identification of the first function is different from the identification of the second function; wherein the identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function of the second function.

Optionally, in other implementations, the processing unit 602 is further configured to: generating first sequence data according to the first registry and a second request generated by a second process running in the client, wherein the first sequence data comprises the second request, the second request carries the identifier of the first function and the first variable information, and the first variable information comprises a first variable and the value of the first variable; the transceiver 601 is further configured to: sending the first sequence data to the server, so that the compiled file of the first code is executed by the first process running in the server to respond to the second request; the transceiver 601 is further configured to: receiving second sequence data from the server, wherein the second sequence data comprises a second response result, the second response result is obtained by transmitting the first variable and the value of the first variable into a compiled file of the first code, and responding to the second request by executing the compiled file of the first code by the first process, and the second response result does not meet preset requirements; and analyzing the second sequence data to obtain a second response result, and transmitting the second response result into the second process, so that the second process successfully calls the first function associated with the first process.

Optionally, in other implementations, third sequence data is generated according to the second registry and a first request generated by a second process running in the client, where the third sequence data includes the first request, the first request carries the second variable information and the identifier of the second function, and the second variable information includes a second variable and a value of the second variable; the transceiver 601 is further configured to: sending the third sequence data to the server, so that the first request is responded by the first process running in the server executing the compiled file of the second code; the transceiver 601 is further configured to: receiving fourth sequence data from the server, wherein the fourth sequence data comprises a first response result, the first response result is a result obtained by transmitting the second variable and the value of the second variable into a compiled file of the second code, and the first process executes the compiled file of the second code to respond to the first request, and the first response result meets a preset requirement; the processing unit 602 is further configured to: and analyzing the fourth sequence data to obtain the first response result, and transmitting the first response result into the second process, so that the second process successfully calls the second function associated with the first process.

Optionally, in another implementation manner, the transceiver 601 is further configured to: receiving a query message sent by the manager, wherein the query message is used for querying whether the second variable information is stored in a storage space accessible to the second process running in the client; the transceiver 601 is further configured to: sending a query response message to the manager, wherein the query response message is used for indicating a storage space accessible to the second process running in the client to store the second variable information.

Fig. 7 is a schematic structural diagram of an upgrade system provided in an embodiment of the present application. As shown in fig. 7, the upgrade system includes a client 701, a server 702, and a manager 703. Taking the scenario shown in fig. 1 as an example, the client 701, the server 702, and the manager 703 shown in fig. 7 are the client 110, the server 120, and the manager 130 shown in fig. 1, respectively.

Wherein, the client is used for executing the steps of the method executed by the client in the above-described upgrading method, the server is used for executing the steps of the method executed by the server in the above-described upgrading method, and the manager is used for executing the steps of the method executed by the manager in the above-described upgrading method. In some implementations, the client 701 and the server 702 are two separate devices. Optionally, in other implementation manners, the client 701 and the server 702 may also be the same device, that is, the device has the functions of the client and the server in the above-described upgrading method.

Fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present application. As shown in fig. 8, includes a memory 801, a processor 802, a communication interface 803, and a communication bus 804. The memory 801, the processor 802, and the communication interface 803 are communicatively connected to each other via a communication bus 804.

The memory 801 may be a Read Only Memory (ROM), a static memory device, a dynamic memory device, or a Random Access Memory (RAM). The memory 801 may store programs, and when the programs stored in the memory 801 are executed by the processor 802, the processor 802 and the communication interface 803 are used to perform the steps of the upgrade method of the embodiments of the present application.

The processor 802 may be a general Central Processing Unit (CPU), a microprocessor, an Application Specific Integrated Circuit (ASIC), a Graphics Processing Unit (GPU), or one or more integrated circuits, and is configured to execute related programs to implement functions required to be executed by units in the upgrading apparatus according to the embodiment of the present application, or to execute steps of the upgrading method according to the embodiment of the present application.

The processor 802 may also be an integrated circuit chip having signal processing capabilities. In implementation, the steps of the upgrade method provided in the present application may be implemented by integrated logic circuits of hardware in the processor 802 or instructions in the form of software. The processor 802 may also be a general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, or discrete hardware components. The various methods, steps, and logic blocks disclosed in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of the method disclosed in connection with the embodiments of the present application may be directly implemented by a hardware decoding processor, or implemented by a combination of hardware and software modules in the decoding processor. The software module may be located in ram, flash memory, rom, prom, or eprom, registers, etc. storage media as is well known in the art. The storage medium is located in the memory 801, and the processor 802 reads information in the memory 801, and completes functions required to be executed by a unit included in the upgrading apparatus according to the embodiment of the present application, or executes the upgrading method according to the embodiment of the method of the present application, in combination with hardware thereof.

The communication interface 803 enables communication between the device shown in fig. 8 and other devices or communication networks using transceiver means such as, but not limited to, transceivers.

The communication bus 804 may include a path that transfers information between the various components of the device shown in fig. 8 (e.g., the memory 801, the processor 802, the communication interface 803).

An embodiment of the present application further provides a computer program product, which includes a computer program, and when the computer program is executed by a processor, the computer program is used to implement the upgrade method according to any one of the above technical solutions.

Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored on a computer-readable medium and include several instructions to enable a computing device (which may be a personal computer, a server, a terminal device, or a network device) to execute the method according to the embodiments of the present disclosure.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include forms of volatile memory in a computer readable medium, random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage media, or any other non-transmission medium, that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include non-transitory computer readable media (transient media), such as modulated data signals and carrier waves.

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

Although the present application has been described with reference to the preferred embodiments, it is not intended to limit the present application, and those skilled in the art can make variations and modifications without departing from the spirit and scope of the present application, therefore, the scope of the present application should be determined by the claims that follow.

Claims (26)

1. An upgrade method applied to a manager by which code is maintained, the method comprising:

receiving a function upgrading instruction, wherein the function upgrading instruction instructs to upgrade a first function in first codes associated with a first process running in a server to a second function, and the second function is different from the first function;

generating a registry updating instruction according to the function upgrading instruction, and sending the registry updating instruction to a client, so that a first registry stored in the client is updated to a second registry in a process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines a function called by at least one function in the codes associated with the second process according to the registry stored in the client, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry;

generating indication information according to the function upgrading instruction, and sending the indication information to the server, so that the server upgrades the compiled file of the first code into the compiled file of the second code, and upgrades the first function into the second function; wherein the indication information indicates a compiled file of the second code, the code including at least the first code and the second code, the second code being a code obtained by performing the operation indicated by the upgrade instruction on the first code.

2. The method of claim 1,

the identification of the first function is the same as that of the second function, and the first variable information is different from the second variable information; or,

the identity of the first function is different from the identity of the second function;

wherein the identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function name of the second function.

3. The method of claim 1, wherein prior to the generating indication information according to the function upgrade instruction, the method further comprises:

and executing the operation indicated by the upgrading instruction on the first code to generate the second code.

4. The method according to claim 1, wherein the indication information is a compiled file of the second code, and before the sending the indication information to the server, the method further comprises:

and compiling the second code to generate a compiled file of the second code.

5. The method of claim 1, wherein the indication information comprises the second code, and wherein the indication information specifically indicates a compiled file from which the second code was generated.

6. The method according to any of claims 1 to 5, wherein before said sending a registry update instruction to said client, said method further comprises:

sending a query message to the client, wherein the query message is used for querying whether the second variable information is stored in a storage space accessible to the second process running in the client;

receiving a query response message from the client, wherein the query response message is used for indicating a storage space accessible to the second process running in the client to store the second variable information.

7. The method of any of claims 1 to 5, wherein receiving the function upgrade instructions comprises:

receiving the function upgrading instruction when the current time reaches the triggering time of a preset upgrading period; or,

receiving the function upgrading instruction when the second response result does not meet the preset requirement; the second response result is obtained by the first process executing the compiled file of the first code to respond to the second request, and the second request carries the identifier of the first function and the first variable information.

8. The method according to any one of claims 1 to 5, wherein before said sending said indication information to said server, said method further comprises:

checking the second code, and determining that the second code meets predefined code requirements, wherein the indication information comprises the second code, and the indication information specifically indicates that a compiled file of the second code is generated according to the second code; or,

and detecting the compiled file of the second code, and determining that the compiled file of the second code meets the predefined compiled file requirement, wherein the indication information is the compiled file of the second code.

9. An upgrading method is applied to a server side, and the method comprises the following steps:

receiving indication information from a manager, wherein the indication information indicates a compiled file of second code, the second code is obtained by executing, by the manager, an operation indicated by a function upgrade instruction on a first function in first code associated with a first process running in the server, the function upgrade instruction indicates that the first function in the first code is upgraded into a second function, and the second function is different from the first function;

according to the indication information, obtaining a compiled file of the second code;

and upgrading the compiled file of the first code to the compiled file of the second code under the condition that the first process is in a running state, so as to upgrade the first function to the second function.

10. The method of claim 9, wherein the indication information is a compiled file of the second code.

11. The method of claim 9, wherein the indication information comprises the second code, wherein the indication information specifically indicates that a compiled file of the second code was generated from the second code,

the obtaining of the compiled file of the second code according to the indication information includes:

and compiling the second code to generate a compiled file of the second code.

12. The method according to any one of claims 9 to 11, wherein the identification of the first function is the same as the identification of the second function, and the first variable information is different from the second variable information, the identification of the first function indicating a function name of the first function,

the upgrading the compiled file of the first code to the compiled file of the second code includes:

determining the address of a compiled file storing the first code in the storage space of the server as a first address according to the identifier of the first function;

and updating the content stored in the first address into a compiled file of the second code.

13. The method according to any of claims 9 to 11, wherein the identity of the first function is different from the identity of the second function,

the server side upgrades the compiled file of the first code into the compiled file of the second code, and the method comprises the following steps:

creating a second address for the function corresponding to the identifier of the second function in the storage space of the server;

storing the compiled file of the second code to the second address.

14. The method of any of claims 9 to 11, wherein prior to said upgrading the compiled file of the first code to the compiled file of the second code, the method further comprises:

receiving first sequence data sent by a client, wherein the first sequence data comprise a second request, variable information carried by the second request is first variable information associated with the first function recorded in a first registry stored in the client, the first variable information comprises a first variable and a value of the first variable, and the second request is a request generated by a second process running in the client;

analyzing the first sequence data to obtain the second request, transmitting the first variable and the value of the first variable into a compiled file of the first code, and executing the compiled file of the first code through the first process to respond to the second request to obtain a second response result, wherein the second response result does not meet preset requirements;

and sending second sequence data to the client to enable the client to transmit the first response result into the second process, wherein the second sequence data comprises the second response result.

15. The method of any of claims 9 to 11, wherein after the upgrading the compiled file of the first code to the compiled file of the second code, the method further comprises:

receiving third sequence data sent by a client, wherein the third sequence data comprises a first request, variable information carried by the first request is second variable information associated with the second function recorded in a second registry stored in the client, the second variable information comprises a second variable and a value of the second variable, and the first request is a request generated by a second process running in the client;

analyzing the third sequence data to obtain the first request, transmitting the second variable and the value of the second variable into a compiled file of the second code, and executing the compiled file of the second code through the first process to respond to the first request to obtain a first response result, wherein the first response result meets a preset requirement;

and sending fourth sequence data to the client to enable the client to transmit the first response result into the second process, wherein the fourth sequence data comprises the first response result.

16. The method according to any one of claims 9 to 11, wherein the function upgrade instruction is received by the manager under any one of the following conditions:

the current moment reaches the trigger moment of the preset upgrading period; or,

a second response result does not meet preset requirements, wherein the second response result is a response result obtained by the first process running in the server terminal transmitting a second request sent by a client terminal into a compiled file of the first code and responding to the second request by the first process executing the compiled file of the first code, the second request carries first variable information associated with the first function recorded in a first registry stored in the client terminal and an identifier of the first function, and the first variable information includes a first variable and a value of the first variable.

17. An upgrading method applied to a client, the method comprising:

receiving a registry updating instruction from a manager, wherein the registry updating instruction is generated by the manager according to a function upgrading instruction, the function upgrading instruction is used for upgrading a first function in first codes associated with a first process running in a server to a second function, the second function is different from the first function, the registry updating instruction is used for instructing to update a first registry stored in the client to a second registry, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry;

and updating the first registry to a second registry according to the registry updating instruction in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client.

18. The method of claim 17,

the identification of the first function is the same as that of the second function, and the first variable information is different from the second variable information; or,

the identity of the first function is different from the identity of the second function;

wherein the identifier of the first function is used for indicating the function name of the first function, and the identifier of the second function is used for indicating the function of the second function.

19. The method of claim 17 or 18, wherein prior to said receiving a registry update instruction from a manager, the method further comprises:

generating first sequence data according to the first registry and a second request generated by a second process running in the client, wherein the first sequence data comprises the second request, the second request carries the identifier of the first function and the first variable information, and the first variable information comprises a first variable and the value of the first variable;

sending the first sequence data to the server, so that the compiled file of the first code is executed by the first process running in the server to respond to the second request;

receiving second sequence data from the server, wherein the second sequence data comprises a second response result, the second response result is obtained by transmitting the first variable and the value of the first variable into a compiled file of the first code, and responding to the second request by executing the compiled file of the first code by the first process, and the second response result does not meet preset requirements;

and analyzing the second sequence data to obtain a second response result, and transmitting the second response result into the second process, so that the second process successfully calls the first function associated with the first process.

20. The method according to claim 17 or 18, wherein after the updating the first registry stored in the client to the second registry according to the registration update instruction, the method further comprises:

generating third sequence data according to the second registry and a first request generated by a second process running in the client, wherein the third sequence data comprises the first request, the first request carries the second variable information and the identifier of the second function, and the second variable information comprises a second variable and the value of the second variable;

sending the third sequence data to the server, so that the first request is responded by the first process running in the server executing the compiled file of the second code;

receiving fourth sequence data from the server, wherein the fourth sequence data comprises a first response result, the first response result is a result obtained by transmitting the second variable and the value of the second variable into a compiled file of the second code, and the first process executes the compiled file of the second code to respond to the first request, and the first response result meets a preset requirement;

and analyzing the fourth sequence data to obtain the first response result, and transmitting the first response result into the second process, so that the second process successfully calls the second function associated with the first process.

21. The method according to claim 17 or 18, wherein before said updating the first registry stored in the client to the second registry, the method further comprises:

receiving a query message sent by the manager, wherein the query message is used for querying whether the second variable information is stored in a storage space accessible to the second process running in the client;

sending a query response message to the manager, wherein the query response message is used for indicating a storage space accessible to the second process running in the client to store the second variable information.

22. An upgrade apparatus, applied to a manager by which code is maintained, the apparatus comprising:

the system comprises a receiving and sending unit, a processing unit and a processing unit, wherein the receiving and sending unit is used for receiving a function upgrading instruction, the function upgrading instruction indicates that a first function in first codes related to a first process running in a server is upgraded into a second function, and the second function is different from the first function;

a processing unit, configured to generate a registry update instruction according to the function upgrade instruction, where the transceiver unit is further configured to: sending the registry updating instruction to a client to update a first registry stored in the client into a second registry in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines a function called by at least one function in the codes associated with the second process according to the registry stored in the client, first variable information associated with the first function is recorded in the first registry, and second variable information associated with the second function is recorded in the second registry;

the processing unit is further to: generating indication information according to the function upgrade instruction, wherein the transceiver unit is further configured to: sending the indication information to the server, and upgrading the compiled file of the first code into a compiled file of a second code so as to upgrade the first function into the second function; wherein the indication information indicates a compiled file of the second code, the code including at least the first code and the second code, the second code being a code obtained by the manager executing the operation indicated by the function upgrade instruction on the first code.

23. An upgrading device, which is applied to a server, the device comprising:

a transceiver unit, configured to receive indication information from a manager, where the indication information indicates a compiled file of a second code, where the second code is obtained by the manager performing an operation indicated by a function upgrade instruction on a first function in a first code associated with a first process running in the server, and the function upgrade instruction indicates to upgrade the first function in the first code to a second function, where the second function is different from the first function;

the processing unit is used for: according to the indication information, obtaining a compiled file of the second code;

the processing unit is further to: and upgrading the compiled file of the first code to the compiled file of the second code so as to upgrade the first function to the second function under the condition that the first process is in the running state.

24. An upgrading device applied to a client, the device comprising:

a transceiver unit, configured to receive a registry update instruction from a manager, where the registry update instruction is generated by the manager according to a function upgrade instruction, the function upgrade instruction indicates that a first function in a first code associated with a first process running in a server is upgraded to a second function, the second function being different from the first function, the registry update instruction is used to indicate that a first registry stored in the client is upgraded to a second registry, first variable information associated with the first function is recorded in the first registry, second variable information associated with the second function is recorded in the second registry, and the first variable information is different from the second variable information;

the processing unit is used for: and updating the first registry to a second registry according to the registry updating instruction in the process that at least one function in codes associated with a second process running in the client calls the first function, wherein the second process determines the function called by at least one function in the codes associated with the second process according to the registry stored in the client.

25. An electronic device, comprising: a memory and a processor, the memory and the processor coupled;

the memory is to store one or more computer instructions;

the processor is configured to execute the one or more computer instructions to implement the method of any of claims 1 to 21.

26. A computer readable storage medium having stored thereon one or more computer instructions for execution by a processor to perform the method of any one of claims 1 to 21.

Images