CN110597541A

CN110597541A - Interface updating processing method, device, equipment and storage medium based on block chain

Info

Publication number: CN110597541A
Application number: CN201910872777.XA
Authority: CN
Inventors: 冯士乘
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2019-09-16
Filing date: 2019-09-16
Publication date: 2019-12-20
Anticipated expiration: 2039-09-16
Also published as: CN110597541B

Abstract

The application relates to a block chain-based interface update processing method, a device, equipment and a storage medium, wherein the method comprises the following steps: acquiring an interface updating task, wherein the interface updating task carries a node identifier and at least one service type to be updated corresponding to the node identifier; acquiring an update package corresponding to the service type to be updated, wherein the service type to be updated corresponds to at least one interface identifier; generating a corresponding interface updating instruction according to the updating packet; and sending the interface updating instruction to a target node corresponding to the node identifier, so that the target node updates a target interface corresponding to the interface identifier based on the updating packet. The scheme provided by the application can effectively improve the updating efficiency of the block chain link point interface.

Description

Interface updating processing method, device, equipment and storage medium based on block chain

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for processing an interface update based on a block chain, a computer device, and a computer-readable storage medium.

Background

With the development of computer technology, blockchain technology has emerged. The blockchain is a novel application mode of computer technologies including distributed data storage, point-to-point transmission, a consensus mechanism, an encryption algorithm and the like. Compared with other distributed systems, the blockchain system has a decentralized feature, and each node on the blockchain realizes self verification, transmission and management of information.

In the service upgrading process of the block chain node, an interface corresponding to the service on the block chain node needs to be updated. In the conventional manner, due to the decentralized feature of the block chain, the user can only download the installation packages one by one on the managed block chain link points and manually perform deployment configuration. The user may manage a plurality of blockchain nodes, and the interface updating efficiency is low by a method of updating the interfaces on the blockchain nodes one by one through complicated operations.

Disclosure of Invention

In view of the foregoing, it is desirable to provide a block chain based interface update processing method, apparatus, computer readable storage medium, and computer device for solving the technical problem of inefficient interface update.

An interface update processing method based on a block chain comprises the following steps:

acquiring an interface updating task, wherein the interface updating task carries a node identifier and at least one service type to be updated corresponding to the node identifier;

acquiring an update package corresponding to the service type to be updated, wherein the service type to be updated corresponds to at least one interface identifier;

generating a corresponding interface updating instruction according to the updating packet;

and sending the interface updating instruction to a target node corresponding to the node identifier, so that the target node updates a target interface corresponding to the interface identifier based on the updating packet.

An apparatus for block chain based interface update processing, the apparatus comprising:

the system comprises a task obtaining module, a task updating module and a service updating module, wherein the task obtaining module is used for obtaining an interface updating task, and the interface updating task carries a node identifier and at least one service type to be updated corresponding to the node identifier;

the update package acquisition module is used for acquiring an update package corresponding to the service type to be updated, wherein the service type to be updated corresponds to at least one interface identifier;

the instruction generating module is used for generating a corresponding interface updating instruction according to the updating packet;

and the interface updating module is used for sending the interface updating instruction to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the interface identifier based on the updating packet.

A computer-readable storage medium storing a computer program which, when executed by a processor, performs the steps of:

A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the following steps when executing the computer program:

According to the interface updating processing method and device based on the block chain, the computer readable storage medium and the computer device, the obtained interface updating task carries the node identification and at least one service type to be updated corresponding to the node identification. And sending an update package corresponding to the service type to be updated to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the service type to be updated according to the update package. Compared with the traditional mode that the target nodes need to be controlled one by one to update the interfaces, the method can update the interfaces on the target nodes at one time, and effectively improves the updating efficiency of the block link node interfaces.

Drawings

FIG. 1 is a diagram of an application environment of a blockchain-based interface update processing method in one embodiment;

FIG. 2 is a flowchart illustrating a block chain based interface update processing method according to an embodiment;

FIG. 3 is an interface diagram of an interface configuration page in one embodiment;

FIG. 4 is a flowchart illustrating the step of obtaining an interface update task according to an embodiment;

FIG. 5 is an interface diagram of a portal page in one embodiment;

FIG. 6 is a timing diagram of a blockchain based interface update processing method in one embodiment;

fig. 7 is a flowchart illustrating an interface update request procedure uploaded by the receiving terminal through the portal page in one embodiment;

FIG. 8 is a block diagram of an interface update processing apparatus based on a blockchain in one embodiment;

FIG. 9 is a block diagram of an interface update processing apparatus based on a blockchain in another embodiment;

FIG. 10 is a block diagram showing a configuration of a computer device according to an embodiment.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.

Fig. 1 is a diagram illustrating an application environment of a blockchain-based interface update processing method according to an embodiment. Referring to fig. 1, the interface update processing method based on a blockchain may be applied to an interface update processing system based on a blockchain. The interface update processing system based on the blockchain comprises a terminal 110, a server 120 and a blockchain 130. Block chain 130 includes a plurality of nodes 131 therein. The terminal 110 and the server 120 are connected via a network, and the server 120 is connected via the network and a node 131 in the blockchain 130. The terminal 110 may specifically be a desktop terminal or a mobile terminal, and the mobile terminal may specifically be at least one of a mobile phone, a tablet computer, a notebook computer, and the like. The server 120 may be implemented as a stand-alone server or a server cluster composed of a plurality of servers. The node 131 may specifically be a blockchain link point in a blockchain system, and a blockchain node may belong to one or more blockchains. The blockchain node may be a desktop terminal or a mobile terminal, or may be an independent server or a server cluster composed of a plurality of servers.

The blockchain is a novel application mode of computer technologies such as distributed data storage, point-to-point transmission, a consensus mechanism and an encryption algorithm. A block chain (Blockchain), which is essentially a decentralized database, is a series of data blocks associated by using a cryptographic method, and each data block contains information of a batch of network transactions, so as to verify the validity (anti-counterfeiting) of the information and generate a next block. The blockchain may include a blockchain underlying platform, a platform product services layer, and an application services layer.

The block chain underlying platform can comprise processing modules such as user management, basic service, intelligent contract and operation monitoring. The user management module is responsible for identity information management of all blockchain participants, and comprises public and private key generation maintenance (account management), key management, user real identity and blockchain address corresponding relation maintenance (authority management) and the like, and under the authorization condition, the user management module supervises and audits the transaction condition of certain real identities and provides rule configuration (wind control audit) of risk control; the basic service module is deployed on all block chain node equipment and used for verifying the validity of the service request, recording the service request to storage after consensus on the valid request is completed, for a new service request, the basic service firstly performs interface adaptation analysis and authentication processing (interface adaptation), then encrypts service information (consensus management) through a consensus algorithm, transmits the service information to a shared account (network communication) completely and consistently after encryption, and performs recording and storage; the intelligent contract module is responsible for registering and issuing contracts, triggering the contracts and executing the contracts, developers can define contract logics through a certain programming language, issue the contract logics to a block chain (contract registration), call keys or other event triggering and executing according to the logics of contract clauses, complete the contract logics and simultaneously provide the function of upgrading and canceling the contracts; the operation monitoring module is mainly responsible for deployment, configuration modification, contract setting, cloud adaptation in the product release process and visual output of real-time states in product operation, such as: alarm, monitoring network conditions, monitoring node equipment health status, and the like.

The platform product service layer provides basic capability and an implementation framework of typical application, and developers can complete block chain implementation of business logic based on the basic capability and the characteristics of the superposed business. The application service layer provides application services based on the block chain scheme to the service participants for use, and the block chain nodes provide the application services outwards through a plurality of interfaces.

As shown in fig. 2, in one embodiment, a block chain based interface update processing method is provided. The embodiment is mainly illustrated by applying the method to the server 120 in fig. 1. Referring to fig. 2, the interface update processing method based on the block chain specifically includes the following steps:

s202, an interface updating task is obtained, and the interface updating task carries a node identifier and at least one service type to be updated corresponding to the node identifier.

The blockchain system may be a node-based service system, and each node may have at least one interface through which the node may provide services corresponding to the service. The node may specifically be a blockchain node on a blockchain, and the Interface may specifically be an API (Application Programming Interface). Each node may provide at least one type of service, the implementation of each service requiring reliance on one or more interfaces. As the service requirement of the node changes, the service provided corresponding to the service needs to be upgraded, and the corresponding interface on the node is updated.

The interface updating task is a task for instructing the server to update the corresponding interface, and the server can update the interfaces of the associated nodes. The interface updating task can carry one or more node identifiers, the node identifiers refer to marking information corresponding to the nodes needing interface updating, and the nodes corresponding to the node identifiers can be marked as target nodes. The unique corresponding mapping relation exists between the node identification and the node, and the server can adopt one or more combinations of various marking information as the node identification. For example, the node identifier may be a set of one or more of a node name, a node IP (internet protocol, protocol for interconnection between networks) address, a node MAC address (Media Access control address), and other information corresponding to the node. The interface updating task may also carry at least one service type to be updated corresponding to each node identifier, and the service types to be updated corresponding to different node identifiers may be the same or different. The server can update the interface corresponding to at least one service type to be updated corresponding to the plurality of nodes according to one interface updating task. The service type to be updated refers to a service type corresponding to a service which needs to be updated. For example, the service type to be updated may be at least one of a published assets service and a shared ledger service provided by the node.

And when the server acquires the interface updating task, executing the interface updating task to update the interface. The server may obtain the interface update task in a variety of ways. Specifically, the server may receive an interface update request sent by the terminal, and immediately generate a corresponding interface update task according to the received interface update request, so as to quickly respond to the request uploaded by the terminal, thereby improving the interface update efficiency.

The server may also generate an interface update task corresponding to the interface update request when a preset condition is met after the interface update request sent by the terminal is received. The preset condition is a condition preset by a user according to actual updating requirements. For example, when the current time recorded by the server meets a preset time period, a corresponding interface update task is generated to perform interface update. The preset time period may be one time period at night, for example, the preset time period may be two points in the morning to five points in the morning, so that the influence of the node interface update on the node service provision is reduced, and the user experience is improved.

The server can also monitor corresponding updating information according to the service type to be updated uploaded by the terminal. When new update information corresponding to the service type to be updated appears in the server, the server can generate an interface update task according to the new update information to update, so that the interface needing to be updated is updated in time. The server can verify whether new update information appears according to the version identification corresponding to the update information. In one embodiment, the server may use one of the above manners of acquiring the interface update task or other manners of acquiring, or may use a combination of two or more manners to acquire the interface update task.

S204, obtaining an updating packet corresponding to the service type to be updated, wherein the service type to be updated corresponds to at least one interface identifier.

The server has deployed thereon a corresponding local database. The server may obtain, from the local database, update information corresponding to the service type to be updated carried by the interface update task, where the update information may include an update package for performing interface update and a version identifier corresponding to the update package. When the service provided by the node is upgraded and updated, the developer can upload the update information corresponding to the service to the server through the corresponding terminal. And the server receives the update information uploaded by the terminal corresponding to the developer, associates the update information with the service type and stores the associated update information and the service type into the local database, so that the server can conveniently acquire an update package corresponding to the service type to be updated from the local database according to the interface update task.

Each type of service provided by a node needs to depend on one or more interfaces, each interface can correspond to different functions, and the interfaces on which the same node depends when different types of services are provided can be different. And a corresponding mapping relation exists between the service type and the interface identifier. In one embodiment, the server may store the mapping between the service type and the interface identification in the form of a mapping table in a local database. The server can determine at least one interface identifier which needs to be updated and corresponds to the service type to be updated according to the service type to be updated carried in the interface updating task and the mapping relation between the service type and the interface identifier.

In one embodiment, a user may configure an interface on which a service provided by a node depends through a terminal. As shown in fig. 3, fig. 3 is an interface schematic diagram of an interface configuration page when a node interface is configured in one embodiment. The terminal corresponding to the user having the management authority for the node can display an interface configuration page on the display interface, the user can select an interface corresponding to the service type through the interface configuration page, the selected interface can be marked as an invocable interface corresponding to the service type, and the unselected interface is an invocable interface corresponding to the service type. And the node can not realize the service corresponding to the service type according to the non-invokable interface corresponding to the service type. For example, referring to FIG. 3, a user may configure two interfaces including interface identifications "3306" and "3307," respectively, for a service type named "digital asset". The terminal can send the interface configuration information selected by the user through the interface configuration page to the server, and the interface configuration information can include a node identifier, a service type and an interface identifier of an available interface corresponding to the service type. The server may store the interface configuration information uploaded by the terminal in a local database. In one embodiment, the server may further send the service type and the interface identifier of the callable interface corresponding to the service type to the node corresponding to the node identifier. The node may store a correspondence between the service type and the interface identifier of the callable interface in a node database of the node, and a corresponding node database may be deployed on each node, so that the node provides the service of the corresponding service type according to the callable interface.

In an embodiment, the interface update task acquired by the server may carry an interface identifier to be updated corresponding to the node identifier. And the developer uploads the updating information corresponding to the interface to the server through the corresponding terminal. The server stores the update information corresponding to the interface identifier in the local database, and the update information may include an update package corresponding to the interface identifier and a version identifier corresponding to the update package. The server can obtain a data packet corresponding to the interface identifier to be updated from the local database according to the interface identifier to be updated carried in the interface updating task, and update the target interface corresponding to the interface identifier according to the data packet corresponding to the interface identifier. In this embodiment, by corresponding the update packet to the interface identifier, the flexibility of updating the node interface is effectively improved.

And S206, generating a corresponding interface updating instruction according to the updating packet.

The server can generate a corresponding interface updating instruction according to the obtained updating packet, the interface updating instruction carries the updating packet corresponding to the service type to be updated, which is obtained by the server from the local database, and the interface updating instruction is used for indicating the target node to update the target interface according to the updating packet. When the interface update task carries a plurality of node identifiers, the server may obtain a plurality of update packages corresponding to different node identifiers according to the service types to be updated respectively corresponding to the plurality of node identifiers. One node identification may correspond to at least one update package. The server can generate interface updating instructions corresponding to different node identifiers according to the updating packets corresponding to the different node identifiers.

And S208, sending the interface updating instruction to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the interface identifier based on the updating packet.

And the server sends the generated interface updating instruction to a target node corresponding to the node identification according to the node identification. Specifically, the server may transparently transmit the interface update instruction to the target node according to the IP address corresponding to the target node. When the server generates interface updating instructions corresponding to the plurality of node identifiers, the server respectively sends the interface updating instructions to corresponding target nodes according to the node identifiers, and the interface updating instructions carry updating packages corresponding to the service types to be updated for the target nodes. And when the target node receives the interface updating instruction, analyzing the carried updating packet according to the interface updating instruction. The update package may include an update data package and an update script. The target node can execute the update script based on the update data packet, so as to update the target interface corresponding to the service type to be updated.

In this embodiment, the server may obtain an interface update task according to interface configuration information or an interface update request sent by the terminal, where the obtained interface update task may include one or more node identifiers and at least one service type to be updated corresponding to each node identifier, and the server may obtain a corresponding update package according to the service type to be updated, where each service type to be updated may correspond to at least one interface identifier. The server may generate an interface update instruction according to the update package, and send the update package to the target node corresponding to the node identifier, so that the at least one target node updates the target interface corresponding to the at least one interface identifier based on the update package. Compared with the traditional mode that the user updates the interfaces of the target nodes one by one, the server in the embodiment can update the interfaces of the plurality of target nodes simultaneously according to the interface configuration information or the interface updating request uploaded by the user through the terminal, so that the updating efficiency of the block link node interfaces is effectively improved.

In an embodiment, as shown in fig. 4, the step of obtaining the interface update task includes:

s402, receiving an interface updating request uploaded by the terminal through the portal page, wherein the interface updating request comprises a request header and a request body.

S404, extracting the access domain name from the request head, and analyzing the access domain name to obtain the node identifier.

S406, at least one service type to be updated corresponding to the node identification is obtained from the request body.

And S408, generating an interface updating task according to the plurality of node identifications and the service type to be updated.

The terminal can be operated with a node control platform, and the node control platform can be a native application program, a web application program or an application subprogram operated in an environment provided by the native application program. The server can be a background server corresponding to the node control platform, and a user can manage a plurality of nodes through the node control platform. For example, the node control platform may be a BaaS (block chain as a Service) platform. In the blockchain system, due to the cost problem, most users usually have difficulty in building a set of blockchain systems owned by themselves, and at this time, a third party may be entrusted to building the blockchain system. For example, a blockchain system can be quickly built using a node control platform. Based on the node control platform, a user can register nodes and connect the nodes into a chain.

The entry page may be a page that the terminal presents based on the node control platform, and serves as a unified entry for controlling different nodes in the blockchain system. As shown in fig. 5, fig. 5 is an interface schematic diagram of an entry page displayed by a terminal in one embodiment. The terminal can show an entry page on the display interface, and the entry page can include the node identification and the service type corresponding to the node identification. The user can directly select the node identification and the service type which need to be updated through the entrance page, so that the complicated operation of manual input of the user is avoided, the efficiency of updating the interface is improved, and meanwhile, the error rate of the manual input is reduced. In one embodiment, the user can access the node through the portal page, and the node control platform can also provide multiple access methods. For example, the access method may include a login method, an information acquisition method, a key configuration method, and the like.

When the user needs to update the interface of the managed node, the user can log in the node control platform based on the user identification and access the entry page based on the entry domain name on the node control platform. The user identification refers to information capable of identifying the user identity, and a unique corresponding mapping relation exists between the user identification and the user identity. The user identification may be a variety of information identifying the identity of the user. For example, the user identifier may be a user account, a contact phone number, a certificate number, and the like corresponding to the user. The entry domain name is a URL (Uniform Resource Locator) corresponding to an entry page, and the entry domain name is information for identifying an electronic location of the server during data transmission, and may be a name of the server composed of a string of names separated by dots.

The terminal can receive the service selection operation triggered by the user at the entry page through the input device, and determine the node identifier pointed by the user and the service type to be updated. The terminal can splice the node identifiers and the access methods based on the first preset identifier to obtain a domain name suffix, and the domain name suffix is spliced to the entry domain name corresponding to the entry page based on the second preset identifier to obtain the access domain name. The terminal can record the access domain name in a request header of the interface updating request, record the service type to be updated in a request body of the interface updating request, and splice the request header and the request body to obtain the interface updating request. And uploading the interface update request to the server. Wherein, the first preset identifier may be "/", "═", "&", "#", "@" or "@". The second preset identifier may be "/". In one embodiment, when a user updates the node interface, the access method may default to a login method.

In one embodiment, the terminal may use a space to separate the request header and the request body when building the interface update request. After receiving the interface updating request, the server acquires the position information of the space in the interface updating request, and divides the interface updating request into a request head part and a request body part based on the position information corresponding to the space.

The server receives an interface updating request uploaded by the terminal through the portal page, wherein the interface updating request can comprise a request header and a request body. The access domain name obtained by terminal splicing is recorded in the request header, and the server can extract the access domain name from the request header. And the server analyzes the extracted access domain name to obtain a node identifier. Specifically, when a user registers a node, a node identifier and a corresponding access method may be configured for the node based on the node control platform, and the server may associate and store the node identifier and the access method corresponding to the node in the local database. And the server performs regular matching on the access domain name, and when the character string matched with the entry domain name corresponding to the entry page comprises the character string in the node identification format and the access method, the server determines that the matching is successful. Otherwise, the matching fails. The server may determine a string in the node identification format as the node identification of the node selected by the user. The request body records data processed by the server, and the server can obtain at least one service type to be updated which needs to be updated from the request body. The server can generate an interface updating task according to the obtained node identification and the service type to be updated, and update a target interface of the target node according to the interface updating task.

Referring to fig. 6, fig. 6 is a timing diagram of an interface update processing method based on the blockchain shown in fig. 4 in an embodiment, as shown in fig. 6, after a user opens an entry page and inputs a node identifier of a target node and a service type to be updated corresponding to the node identifier through the entry page, a terminal generates an interface update request according to the node identifier and the service type to be updated. After receiving the interface updating request, the server extracts the access domain name from the request head of the interface updating request, analyzes the access domain name to obtain the node identifier, and acquires the service type to be updated corresponding to the node identifier from the request body of the interface updating request. And the server generates an interface updating task according to the node identification and the service type to be updated. And the server acquires a corresponding update package according to the service type to be updated carried in the interface update task, generates a corresponding interface update instruction according to the update package, and sends the interface update instruction to a target node corresponding to the node identifier. And the target node updates the target interface corresponding to the interface identifier based on an update packet carried by the interface update instruction.

In this embodiment, the terminal may upload an interface update request through the portal page, and the server may determine, through an access domain name in the interface update request uploaded by the terminal, a node identifier that needs to be subjected to interface update, and obtain a service type to be updated from a request body of the interface update request. The server sends the update package corresponding to the service type to be updated to the target node corresponding to the node identifier, and a domain name does not need to be configured for each target node, so that domain name resources are effectively saved.

In one embodiment, extracting the access domain name from the request header, and analyzing the access domain name to obtain the node identifier includes: acquiring an entry domain name corresponding to an entry page; extracting a suffix domain name following the IP domain name from the visited domain name when the entry domain name includes the IP address; and calling a preset regular expression to perform regular matching on the suffix domain name to obtain the node identifier.

The suffix domain name refers to a character string spliced after the entry domain name in the access domain name, and the character string may be specifically obtained by splicing a node identifier of a target node selected by a user and an access method for accessing the target node. The portal domain name can be the name of a computer or group of computers that is composed of a string of dotted names, or can be the IP address to which the portal page is mapped. The IP address mapped by the entry domain name may be obtained by the terminal through querying in a domain name and IP address mapping table pre-stored in the domain name server based on the entry domain name. It is understood that the access domain name of the target node may also be obtained by splicing based on the IP address corresponding to the entry domain name.

Specifically, when the portal domain name is a computer name, the terminal can directly access the portal page according to the portal domain name. The terminal can perform regular matching on the access domain name to obtain the node identifier and the access method. When the entry domain name is an IP address, the terminal may access the entry page based on the IP address corresponding to the entry domain name. The server acquires a pre-stored IP address and records the pre-stored IP address as an entrance IP address. The server can analyze the access domain name and judge whether the access domain name contains the entrance IP address.

When the access domain name includes the entry IP address, the server may segment the access domain name based on the entry IP address to obtain a suffix domain name after the entry IP address. The server may determine the number of characters corresponding to the portal IP address. And the server determines a segmentation position between the sequential characters corresponding to the number of the characters and the next sequential characters in the access domain name, and segments the access domain name at the segmentation position to obtain an entrance IP address and a suffix domain name. For example, the access domain name may be "192.123.0.1/192.168.10.11/login". Wherein, "192.123.0.1" is the entry IP address, "192.168.10.11" is the node identifier, and "login" is the access method. The number of characters corresponding to the entry IP address is 11, and the server may determine a position between the 11 th character "1" and the 12 th character "/" as a division position, which is divided into suffix domain names "/192.168.10.11/login".

In one embodiment, the server may segment the access domain name based on the second preset to obtain the ingress IP address and the suffix domain name.

For example, when the preset regular expression comprises ^ (?: [0-9] {1,3} \) {3} [0-9] {1,3}, $/login "," ^ (?: [0-9] {1,3 }) {3} [0-9] {1,3}, $/getInfo ", the matching of"/login "{ 3} [0-9] {1,3}, $" can obtain "192.168.10.11" based on "^ (?: [0-9] {1,3}, \\) {3} [0-9], {1,3}," matching, obtain "/login" matching ", wherein the" (?: [0-9] {1,3 }) is used for "matching of"/3 }, "[ 0-9]," "represents a small number of matching of" $ 0-3 }, "3" $ "3" -, "3" - "matches".

In one embodiment, after obtaining the suffix domain name, the server may segment the suffix domain name based on the first preset character to obtain the node identifier and the corresponding access method.

In this embodiment, the server performs regular matching on the suffix domain name, so as to quickly match the node identifier in the interface update request, and further quickly send the interface update instruction to the target node corresponding to the node identifier, so that the target node updates the interface, thereby effectively improving the efficiency of interface update.

In one embodiment, when a user registers a node, the user may configure a corresponding key pair for the registered node, and send the key pair and the node identifier of the registered node to the server. The server may store the key pair and corresponding node identification association in a local database. Different nodes are also provided with respective corresponding node databases, and the server can send the key pairs configured by the user through the terminal to the nodes corresponding to the node identifiers, so that the nodes store the key pairs into the respective node databases. When the key pair includes a public key and a private key, the server may store only the public key corresponding to the node identifier in the local database, and send the private key in the key pair to the node corresponding to the node identifier, so that the node stores the private key in the node database. After the server obtains the access domain name through analysis, the server can query a public key corresponding to the node identifier from a local database according to the node identifier of the target node, encrypt an update package corresponding to the service type to be updated based on the public key, and generate an interface update instruction according to the encrypted update package.

In this embodiment, the server encrypts the update packet and sends the encrypted update packet to the node, so that the probability that the update packet is tampered in the transmission process can be reduced, and the server can send the complete and undistorted data of the update packet to the target node corresponding to the node identifier. Meanwhile, after the node receives the update package, the node can decrypt the update package only by possessing the private key corresponding to the public key, so that the security of the update package is improved, the node is prevented from updating the interface based on the update package which does not correspond, and the accuracy of the interface updating is effectively improved.

In an embodiment, as shown in fig. 7, the step of receiving the interface update request uploaded by the terminal through the portal page includes:

s702, when a node display request uploaded by the terminal is received, registered node information is obtained.

S704, the registered node identification and the service type corresponding to the registered node identification are extracted from the registered node information.

S706, the registered node identification and the service type are returned to the terminal, so that the terminal is displayed on an entry page.

S708, the receiving terminal generates an interface updating request according to the selected node identification and the service type to be updated from the registered node identification and the service type.

The user can trigger the control in the entry page through the terminal, so that the terminal uploads the node display request to the server. The node display request is used for instructing the server to display the node information in the entry page. And after receiving the node display request uploaded by the terminal, the server acquires the registered node information from the local database. When a user registers a node based on the node control platform, the server can record node information such as a node name, a node IP address, a public key, a private key signature, a service type of a provided service, a user identifier and the like which are correspondingly configured by the node. And the server stores node information corresponding to all the registered nodes in a local database of the server in an associated manner. The server can divide the node information corresponding to different node identifications according to the node identifications, and send the node information corresponding to different identifications to the nodes corresponding to the respective node identifications, and the nodes can store the node information of the nodes in the corresponding node databases.

The registered node information obtained by the server from the local database may be node information corresponding to all registered nodes. And the server extracts the registered node identification and the service type corresponding to the registered node identification from the registered node information. And the server returns the registered node identification and the service type corresponding to the registered node identification to the terminal, so that the terminal displays the registered node identification and the service type corresponding to the registered node identification on an entry page. As shown in fig. 5 in the foregoing embodiment, fig. 5 is an interface diagram of a portal page in which a terminal displays registered node identifiers and corresponding service types in one embodiment. The terminal can show the registered node identification and the corresponding service type returned by the server on the portal page.

The terminal can receive the service selection operation triggered by the user at the entry page, and obtain the node identifier and the service type pointed by the service selection operation. The node identifier and the service type to which the service selection operation is directed are the node identifier corresponding to the target node selected by the user and the service type to be updated on the target node, which needs to be updated. The terminal can splice the entry domain name and the node identifier corresponding to the entry page to obtain the access domain name corresponding to the target node. The terminal records the access domain name in the request head, records the service type to be updated in the request body, and obtains the interface updating request by splicing the request head and the request body. The server can receive an interface updating request uploaded by the terminal so as to update the corresponding target interface.

In this embodiment, the server may return the registered node identifier in the registered node information and the service type corresponding to the registered node identifier to the terminal according to the node display request uploaded by the terminal, so that the terminal displays the registered node identifier and the corresponding service type on the entry page. The user can directly select the node identification corresponding to the target node needing interface updating and the service type to be updated in the target node through the entry page, so that the condition that the user manually inputs the node identification and the service type to be updated through complicated operation is avoided, and the efficiency of updating the target node interface is effectively improved.

In an embodiment, the node display request further carries a screening condition, and the step of extracting the registered node identifier and the service type corresponding to the registered node identifier from the registered node information includes: screening the registered node information according to the screening conditions; and extracting the registered node identification and the service type corresponding to the registered node identification from the screened node information.

The node display request uploaded to the server by the terminal can carry screening conditions, the server can screen all registered node information according to the screening conditions, and only the node identification and the corresponding service type in the registered node information meeting the screening conditions are returned to the terminal. The screening condition carried in the node exhibition request may be any one of a plurality of conditions or a combination of any plurality of conditions. For example, the filtering condition may be a user identifier corresponding to the login node control platform, and the server may obtain node information corresponding to the user identifier from all registered node information in the local database. The server may also obtain node information from a node database of nodes corresponding to the user identification. The screening condition may also be registration time, and the server screens the node information corresponding to the node registered in the registration time from the local database. The screening conditions may also be one or a combination of more of the other conditions. For example, the filtering condition may be a combination of the user identifier and the registration time. The server screens the node information meeting the screening condition from all the registered node information and returns the node identification and the service type in the node information meeting the screening condition to the terminal.

In this embodiment, all registered node information in the server database is screened according to the screening condition carried in the interface update request uploaded by the terminal, so as to screen out node information meeting the screening condition. The node identification is extracted from the node information meeting the screening condition, and the service type corresponding to the node identification is returned to the terminal, so that the terminal displays the screened node identification and service type in the entry page, a user can conveniently and quickly select the node identification and service type needing interface upgrading from the registered node identification displayed by the terminal, and the efficiency of interface updating is effectively improved.

In one embodiment, the interface update task further carries a user identifier, and the method further includes: acquiring a node identification set associated with a user identification from registered node information; checking whether the node identification belongs to the node identification set or not; and when the node identification belongs to the node identification set, executing the step of acquiring the update package corresponding to the service type to be updated.

The interface updating task also carries a user identifier, and the user identifier can be used for identifying a user identity corresponding to a user logging in the node control platform. The server can check the authority of the corresponding user identity according to the user identification carried in the interface updating task, and judge whether the user corresponding to the user identification has the target node corresponding to the authority control node identification to update the interface.

Specifically, the server may obtain a node identification set associated with the user identification from the registered node information. The node identification set is a cluster formed by all node identifications associated with the user identification in a local database of the server. The server can store the corresponding node identification and the user identification in a local database in an associated manner when the user registers the node, and send the user identification to the target node corresponding to the associated node identification, so that the target node stores the user identification in the node database.

The server may compare the node identifier in the interface update task with the node identifier set, and check whether the node identifier belongs to the node identifier set corresponding to the user identifier. When the node identifier belongs to the node identifier set, it is determined that the identity verification is successful, and it can be considered that the user corresponding to the user identifier has the authority to control the target node corresponding to the node identifier to perform interface update. The server may continue to perform the step of obtaining the update package corresponding to the service type to be updated. In an embodiment, when the node identifier does not belong to the node identifier set, it is determined that the identity verification fails, and it may be considered that the user corresponding to the user identifier does not have the authority to control the node identifier to perform interface update on the target node. The server may return an identity verification failure prompt to the terminal.

In this embodiment, the server checks the node identifier in the interface update task through the node identifier set associated with the user identifier, and checks whether the user corresponding to the user identifier has a control right for the target node. And when the verification is successful, the server continues to execute the subsequent step of acquiring the update package, so that the user without permission is prevented from controlling the target node to update the interface, and the safety of the target node is effectively improved. Meanwhile, the server is prevented from executing unnecessary operations, and the running resources of the server are saved.

In one embodiment, after the server successfully verifies, the server generates an authority verification request based on the user identifier and sends the authority verification request to a target node corresponding to the node identifier. And the target node extracts the user identification from the right verification request and verifies whether the user identification exists in a node database corresponding to the target node. And when the user identification exists in the node database, determining that the user has the control authority to the target node corresponding to the node identification. And the target node returns a successful verification result to the server, and the server continues to execute the step of acquiring the update package corresponding to the service type to be updated after receiving the successful verification result.

In this embodiment, after the server is successfully verified, the target node verifies the user identifier. Through the double authority verification of the server and the target node, the reliability of the authority verification is effectively improved.

In one embodiment, sending the interface update instruction to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the interface identifier based on the update packet includes: asynchronously sending an update package to a target node corresponding to the associated node identifier, wherein the update package comprises an update data package and an update script; and instructing the target node to replace the current data packet with the update data packet according to the interface update instruction, and calling the multithreading parallel execution update script based on the update data packet.

And after generating the interface updating instruction, the server sends the interface updating instruction to a target node corresponding to the node identification in an asynchronous transmission mode. And when the server generates interface updating instructions corresponding to the node identifiers according to the updating packets, the server respectively asynchronously transmits the interface updating instructions to the target nodes corresponding to the node identifiers. The update package corresponding to the service type to be updated may include an update data package and an update script, and the update data package records data for updating the corresponding interface. And the server sends the interface updating instruction to the target node, so that the target node analyzes the updating packet, and replaces the current data packet of the interface with the updating data packet in the updating packet.

In one embodiment, the target node may obtain a version identifier corresponding to an update packet in the update packet, compare the version identifier corresponding to the update packet with a version identifier corresponding to a current packet, and replace the current packet corresponding to the target interface with the update packet only when the version corresponding to the update packet is updated compared with the current packet. By checking the version identification corresponding to the update data packet, interface update by adopting a non-newer update data packet is avoided, and the accuracy of the interface update is effectively improved.

And the target node executes the updating script based on the replaced updating data packet so as to update the target interface corresponding to the service type to be updated. When a plurality of service types to be updated in one target node need to be updated, a plurality of update packages corresponding to the plurality of service types to be updated are carried in the interface update instruction. The target node can call multiple threads from the thread pool and execute the updating scripts in the multiple updating packages in parallel, and therefore multiple target interfaces corresponding to multiple service types are updated simultaneously.

In this embodiment, the server asynchronously sends the update package to the target node corresponding to the node identifier, the target node replaces the current data package with the update data package in the update package, and invokes the multithreading parallel execution update script based on the update data package, and updates the plurality of target interfaces in the target node, thereby effectively improving the update efficiency of the interfaces.

In one embodiment, the method further comprises: before executing the updating script, indicating a target node to back up a current data packet corresponding to a target interface according to an interface updating instruction; when a rollback task is received, obtaining a rollback script corresponding to a current data packet; and sending the rollback script to the target node, so that the target node executes the rollback script based on the current data packet.

The server may also instruct the target node to backup a current data packet currently corresponding to the target interface before executing the update script, according to the interface update instruction sent by the server to the target node. The target node may perform backup storage on a current data packet corresponding to the target interface to which the update packet is directed according to the interface update instruction, and then replace the current data packet with the update data packet to perform interface update.

And when the server receives the rollback task, the server acquires a rollback script corresponding to the current data packet according to the rollback task. In particular, the server may receive the rollback task in a variety of ways. For example, the terminal may trigger a rollback request according to a user instruction, and send the rollback request to the server. The server can generate a rollback task according to the rollback request uploaded by the terminal. The server can also generate a rollback task to perform rollback when the update package fails to be issued.

And the server sends the rollback script to the corresponding target node, and the target node can replace the update data packet adopted during interface update by using the backup current data packet after receiving the rollback script. The target node can execute the rollback script issued by the server based on the replaced current data packet, so as to realize the version rollback of the target interface.

In this embodiment, before the target node executes the update script, the interface update instruction sent by the server to the target node instructs the target node to backup the current data packet corresponding to the target interface, and when receiving the rollback task, the server obtains the rollback script corresponding to the current data packet. The server sends the rollback script to the target node, so that the target node can execute the rollback script based on the current data packet, rollback of the target interface version is achieved, and flexibility of interface updating is effectively improved.

Fig. 2, 4, and 7 are respectively schematic flowcharts of interface update processing methods based on a block chain in an embodiment. It should be understood that although the various steps in the flowcharts of fig. 2, 4 and 7 are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least some of the steps in fig. 2, 4 and 7 may include multiple sub-steps or multiple stages that are not necessarily performed at the same time, but may be performed at different times, and the order of performing the sub-steps or stages is not necessarily sequential, but may be performed alternately or alternatingly with other steps or at least some of the sub-steps or stages of other steps.

In one embodiment, as shown in fig. 8, there is provided a blockchain-based interface update processing apparatus 800, including: a task obtaining module 802, an update package obtaining module 804, an instruction generating module 806, and an interface updating module 808, wherein:

the task obtaining module 802 is configured to obtain an interface update task, where the interface update task carries a node identifier and at least one service type to be updated corresponding to the node identifier.

An update package obtaining module 804, configured to obtain an update package corresponding to a service type to be updated, where the service type to be updated corresponds to at least one interface identifier.

And the instruction generating module 806 is configured to generate a corresponding interface update instruction according to the update package.

The interface updating module 808 is configured to send the interface updating instruction to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the interface identifier based on the update packet.

In one embodiment, as shown in fig. 9, the task obtaining module 802 includes: a request receiving module 8021, a domain name resolution module 8022, a service type obtaining module 8023, and a task generating module 8024, wherein:

the request receiving module 8021 is configured to receive an interface update request uploaded by the terminal through the portal page, where the interface update request includes a request header and a request body.

And a domain name resolution module 8022, configured to extract the access domain name from the request header, and perform resolution on the access domain name to obtain the node identifier.

A service type obtaining module 8023, configured to obtain at least one service type to be updated corresponding to the node identifier from the request body.

And a task generating module 8024, configured to generate an interface update task according to the node identifier and the service type to be updated.

In an embodiment, the domain name resolution module 8022 is further configured to obtain an entry domain name corresponding to an entry page; when the entry domain name includes an IP address, extracting a suffix domain name following the IP address from the visited domain name; and calling a preset regular expression to perform regular matching on the suffix domain name to obtain the node identifier.

In an embodiment, the request receiving module 8021 is further configured to, when receiving a node display request uploaded by a terminal, obtain registered node information; extracting the registered node identification and the service type corresponding to the registered node identification from the registered node information; returning the registered node identification and the service type to the terminal, so that the terminal is displayed on an entry page; and the receiving terminal generates an interface updating request according to the selected node identification and the service type to be updated from the registered node identification and the service type.

In an embodiment, the node display request further carries a screening condition, and the request receiving module 8021 is further configured to screen the registered node information according to the screening condition; and extracting the registered node identification and the service type corresponding to the registered node identification from the screened node information.

In an embodiment, the interface update task further carries a user identifier, and the interface update processing apparatus 800 based on the block chain further includes an identity verification module, configured to obtain a node identifier set associated with the user identifier from the registered node information; checking whether the node identification belongs to the node identification set or not; and when the node identification belongs to the node identification set, executing the step of acquiring the update package corresponding to the service type to be updated.

In one embodiment, the interface update module 808 is further configured to asynchronously send an update package to a target node corresponding to the associated node identifier, where the update package includes an update data package and an update script; and instructing the target node to replace the current data packet with the update data packet according to the interface update instruction, and calling the multithreading parallel execution update script based on the update data packet.

In an embodiment, the interface update processing apparatus 800 based on the blockchain further includes a version rollback module, configured to instruct, according to the interface update instruction, the target node to backup a current data packet corresponding to the target interface before executing the update script; when a rollback task is received, obtaining a rollback script corresponding to a current data packet; and sending the rollback script to the target node, so that the target node executes the rollback script based on the current data packet.

FIG. 10 is a diagram illustrating an internal structure of a computer device in one embodiment. The computer device may specifically be the server 120 in fig. 1. As shown in fig. 10, the computer device includes a processor, a memory, a network interface, and a database connected by a system bus. Wherein the memory includes a non-volatile storage medium and an internal memory. The non-volatile storage medium of the computer device stores an operating system and may also store a computer program that, when executed by the processor, causes the processor to implement a blockchain-based interface update processing method. The internal memory may also store a computer program, and when the computer program is executed by the processor, the computer program may cause the processor to perform the interface update processing method based on the blockchain.

Those skilled in the art will appreciate that the architecture shown in fig. 10 is merely a block diagram of some of the structures associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.

In one embodiment, the interface update processing apparatus based on a blockchain provided in the present application may be implemented in the form of a computer program, and the computer program may be run on a computer device as shown in fig. 10. The memory of the computer device may store various program modules constituting the interface update processing apparatus based on the blockchain, such as a task obtaining module 802, an update packet obtaining module 804, an instruction generating module 806, and an interface updating module 808 shown in fig. 8. The computer program constituted by the respective program modules causes the processor to execute the steps in the block chain based interface update processing method according to the respective embodiments of the present application described in the present specification.

For example, the computer device shown in fig. 10 may execute an interface update task by using the task obtaining module 802 in the interface update processing apparatus based on the blockchain as shown in fig. 8, where the interface update task carries a node identifier and at least one service type to be updated corresponding to the node identifier. The computer device may execute, by the update package obtaining module 804, obtaining an update package corresponding to a service type to be updated, where the service type to be updated corresponds to at least one interface identifier. The computer device may execute the corresponding interface update instructions generated from the update package via the instruction generation module 806. The computer device may execute, through the interface update module 808, sending the interface update instruction to the target node corresponding to the node identifier, so that the target node updates the target interface corresponding to the interface identifier based on the update package.

In one embodiment, a computer device is provided, which comprises a memory and a processor, the memory storing a computer program, the computer program, when executed by the processor, causing the processor to perform the steps of the above block chain based interface update processing method. Here, the steps of the interface update processing method based on the blockchain may be steps in the interface update processing method based on the blockchain in the above embodiments.

In one embodiment, a computer-readable storage medium is provided, which stores a computer program, which, when executed by a processor, causes the processor to perform the steps of the above block chain based interface update processing method. Here, the steps of the interface update processing method based on the blockchain may be steps in the interface update processing method based on the blockchain in the above embodiments.

It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a non-volatile computer-readable storage medium, and can include the processes of the embodiments of the methods described above when the program is executed. Any reference to memory, storage, database, or other medium used in the embodiments provided herein may include non-volatile and/or volatile memory, among others. Non-volatile memory can include read-only memory (ROM), Programmable ROM (PROM), Electrically Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms such as Static RAM (SRAM), Dynamic RAM (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), Synchronous Link DRAM (SLDRAM), Rambus Direct RAM (RDRAM), direct bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.

The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the present application. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.

Claims

1. An interface update processing method based on a block chain comprises the following steps:

2. The method of claim 1, wherein obtaining the interface update task comprises:

receiving an interface updating request uploaded by a terminal through an entry page, wherein the interface updating request comprises a request head and a request body;

extracting an access domain name from the request head, and analyzing the access domain name to obtain a node identifier;

acquiring at least one service type to be updated corresponding to the node identification from the request body;

and generating the interface updating task according to the node identification and the service type to be updated.

3. The method according to claim 2, wherein the receiving of the interface update request uploaded by the terminal through the portal page comprises:

when a node display request uploaded by the terminal is received, registered node information is obtained;

extracting registered node identification and a service type corresponding to the registered node identification from the registered node information;

returning the registered node identification and the service type to the terminal, so that the terminal is displayed on the entry page;

and receiving the interface updating request generated by the terminal according to the selected node identification and the service type to be updated from the registered node identification and the service type.

4. The method according to claim 3, wherein the node exhibition request further carries a screening condition, and the extracting of the registered node identifier and the service type corresponding to the registered node identifier from the registered node information comprises:

screening the registered node information according to the screening condition;

and extracting the registered node identification and the service type corresponding to the registered node identification from the screened node information.

5. The method according to claim 1, wherein the sending the interface update instruction to the destination node corresponding to the node identifier, so that the destination node updates the destination interface corresponding to the interface identifier based on the update package comprises:

asynchronously sending the update package to a target node corresponding to the associated node identifier, wherein the update package comprises an update data package and an update script;

and instructing the target node to replace the current data packet with the update data packet according to the interface update instruction, and calling multithreading based on the update data packet to execute the update script in parallel.

6. The method of claim 1, further comprising:

before executing the updating script, indicating the target node to back up a current data packet corresponding to the target interface according to the interface updating instruction;

when a rollback task is received, obtaining a rollback script corresponding to the current data packet;

and sending the rollback script to the target node, so that the target node executes the rollback script based on the current data packet.

7. The method according to any one of claims 1-6, wherein the interface update task also carries a user identification, the method further comprising:

acquiring a node identification set associated with the user identification from the registered node information;

checking whether the node identification belongs to the node identification set;

and when the node identification belongs to the node identification set, executing the step of acquiring the update package corresponding to the service type to be updated.

8. An apparatus for processing interface update based on block chains, the apparatus comprising:

9. A computer-readable storage medium, storing a computer program which, when executed by a processor, causes the processor to carry out the steps of the method according to any one of claims 1 to 7.

10. A computer device comprising a memory and a processor, the memory storing a computer program that, when executed by the processor, causes the processor to perform the steps of the method according to any one of claims 1 to 7.