CN114584940B

CN114584940B - Slice service processing method and device

Info

Publication number: CN114584940B
Application number: CN202011377289.0A
Authority: CN
Inventors: 薛开平; 田航宇; 洪佳楠
Original assignee: University of Science and Technology of China USTC; Huawei Technologies Co Ltd
Current assignee: University of Science and Technology of China USTC; Huawei Technologies Co Ltd
Priority date: 2020-11-30
Filing date: 2020-11-30
Publication date: 2023-09-01
Anticipated expiration: 2040-11-30
Also published as: CN114584940A; WO2022111658A1

Abstract

The application provides a slice service processing method and device. The method can verify whether the slice service has the service capability of the slice service which the operator node claims to provide, and when the slice service has the service capability of the slice service which the operator node claims to provide, writing test passing information of the slice service into the blockchain; the test pass information of the slice service is used to activate the slice service to the tenant node and pay a service fee to the operator node, the service fee being paid by the tenant node for the slice service provided by the operator node. Therefore, the application sends the payment service fee to the operator when the slice service test passes, and the operator provides the service to the tenant after obtaining the service fee, thereby solving the trust problem between the operator and the tenant.

Description

Slice service processing method and device

Technical Field

The present application relates to the field of communications technologies, and in particular, to a slice service processing method and apparatus.

Background

Currently, communication technology has become a catalyst for social digitization, and mobile communication will continue to develop in the future and needs to meet various communication demands. For example, one business client may require ultra-reliable service, while other business clients may require ultra-high bandwidth communications or very low latency. The design of the 5G network needs to be able to simultaneously provide different hybrid capabilities to meet all these different requirements, so that the concept of network slicing is introduced, shared physical network resources can be dynamically and efficiently scheduled to logical network slices according to the continuously changing requirements, and each network slice is rented to the corresponding tenant, so that the network resources can be effectively utilized, and the capital expenditure and the operation cost can be reduced.

However, there is also a trust problem between the operator and the tenant in the process that the operator rents the network slices to the tenant, for example, the tenant may not be able to obtain the slicing service of the service capability claimed by the operator after providing the service fee to the operator, or the service fee paid by the tenant may not be able to be obtained after providing the slicing service to the tenant by the operator.

Disclosure of Invention

The embodiment of the application provides a slice service processing method and device, which solve the trust problem between operators and tenants.

In a first aspect, the present application provides a slice service processing method, which can be illustrated from the point of view of an authentication node. The method comprises the following steps: the verification node verifies whether the slice service has the service capability of the slice service purported to be provided by the operator node; when the slicing service has the service capability of the slicing service purported to be provided by the operator node, the verification node writes the test passing information of the slicing service into the blockchain; the test pass information of the slice service is used to activate the slice service to the tenant node and pay a service fee to the operator node, the service fee paid by the tenant node for providing the slice service to the operator node. Thus, when the operator node activates the slicing service, the service fee can be obtained, and the cheating by the tenant node is avoided.

In one embodiment, the validation node validates whether the slice service has the service capability of the slice service purported to be provided by the operator node, comprising: and the verification node determines whether the slice service passes the test according to the test result and the decision parameter of the slice service passing test in the slice contract, wherein the test result is used for indicating the service capability of the slice service provided by the operator node.

In one embodiment, a validation node writes test passing information for slice services into a blockchain, comprising: the verification node writes test passing information of the slicing service into the slicing contract; the test passing information is specifically used for activating a slicing contract to call a tenant contract to send a payment certificate to an operator node and sending a notification message to the tenant node; the payment voucher is evidence that the slice contract calls the tenant contract to pay the service fee to the operator node; the notification message is used to notify the tenant node that the operator node has activated the slicing service.

In one embodiment, the validation node receives a test result that the listening node listens to the slicing service provided by the operator node to the test node.

In one embodiment, the master node performs the operations related to the verification node, and before the master node receives the test result, the slice service processing method further includes: the master node selects a test node from nodes participating in block chain consensus by using a random selection algorithm; the main node informs the test node to write test request information into the slice contract according to an external test interface and a resource validity test mode defined by an operator node in the slice contract aiming at the slice service; the test request information comprises an address of a test node, and the test request information is used for indicating an operator node to provide slicing service for the test node.

In one embodiment, the related operation of the verification node is performed by a master node, and the master node selects a test node from nodes participating in blockchain consensus by using a random selection algorithm, including: the master node verifies whether the random numbers respectively published in the plurality of nodes are matched with the previously respectively published hash values, wherein the hash values are obtained by carrying out hash operation on the random numbers by the nodes; the master node determines a test node from the matched plurality of nodes using a mapping operation. The mapping operation may include a modulo operation; the method comprises the steps that a main node obtains a modular operation value through modular operation, and a test node is determined from a plurality of matched nodes according to the modular operation value, wherein the modular operation value is obtained by carrying out modular operation on N through a combined hash value, the combined hash value is obtained by carrying out combined hash operation through random numbers of the plurality of matched nodes, and N is the number of the plurality of nodes. Through the implementation mode, fairness and effectiveness of a random node selection process are guaranteed.

In one embodiment, the slice service processing method further includes: the random numbers and hash values published by the nodes are recorded in the slice contracts. Optionally, the joint hash value and N when the mapping operation is a modulo operation may be recorded in a slice contract, so as to record a process that the master node randomly selects the test node.

In one embodiment, the notarization third party node performs the related operation of the verification node, and writes test request information into the slice contract, wherein the test request information comprises the address of the notarization third party node; the notarization third party node obtains a test result by using a slicing service provided by an operator node; the test results are used to indicate the service capabilities of the slice services provided by the operator node to the notarized third party node. The slice service is tested through the notarized third party node, and the testing efficiency is improved.

In one embodiment, the method further comprises: the slicing contracts are also used for calling directory contracts and updating slicing services into rented slicing services in the directory contracts, so that the slicing services provided by the operator node are published to be provided for the tenant nodes, further, other tenant nodes are informed that the slicing services are used, the fact that the other tenant nodes repeatedly select the slicing services is avoided, and further, the efficiency of selecting proper slicing services by the other tenant nodes is improved.

In a second aspect, the present application provides a slice service processing method, which corresponds to the slice service processing method in the first aspect, and is described from the perspective of a tenant node. The method comprises the following steps: the tenant node receives a notification message from the blockchain, wherein the notification message is sent when the test of the slice service passes through the information writing blockchain and is used for indicating that the operator node has activated the slice service; the slicing service is provided by an operator node selected by the tenant node; the tenant node responds to the notification message and uses the slicing service provided by the operator node. Thus, when the operator node activates the slicing service, the service fee can be obtained, and the cheating by the tenant node is avoided.

In one embodiment, a tenant node receives a notification message from a blockchain, comprising: the tenant node receives a notification message from the tenant contract, wherein the notification message is specifically sent by calling the tenant contract when the slice contract is activated when the test passing information of the slice service is written into the slice contract.

In one embodiment, the tenant node responds to the notification message by using a slicing service provided by the operator node, including: and the tenant node responds to the notification message, and uses the slicing service provided by the operator node according to the external use interface of the slicing service in the slicing contract.

In one embodiment, before the tenant node receives the notification message from the blockchain, the slice service processing method further includes: the tenant node selects an operator node for providing slicing service according to a directory contract, wherein the directory contract comprises information for maintaining slicing service provided by each operator node of a blockchain; the tenant node determines a tenant contract, wherein the tenant contract comprises interface information of the tenant node, information of slicing services selected by the tenant node, an operator node and service fees paid by the tenant node for the slicing services. Therefore, when the test passing information is written in the slicing contract, the slicing contract is activated to call the tenant contract to pay the service fee to the corresponding operator node, and the operator node is prevented from being deceptively deceived by the tenant node.

In one embodiment, a tenant node selects an operator node providing a slicing service according to a directory contract, comprising: the tenant node inquires whether the slice directory contract contains the needed slice service or not, wherein the slice directory contract comprises the information of each slice service deployed by each operator node; if the service provider node exists, selecting an operator node for providing slicing service by the tenant node; if not, the tenant node inquires whether the operator node in the resource directory contract has the service capability of providing slicing service; if the operator node in the resource directory contract has a service capability to provide the slicing service, the tenant node selects the operator node having the service capability to provide the slicing service. Therefore, each operator node can record own slicing service on the blockchain for the tenant to inquire, and correspondingly, the tenant node can select the operator node providing the corresponding slicing service through the directory contract or apply for the slicing service to the corresponding operator node, so that the operator node prepares the slicing service through the slicing management system and defines the relevant information of the slicing service in the slicing contract, and compared with the mode that the tenant node needs to apply for inquiring the slicing service to different operator nodes respectively, the renting efficiency of the slicing service can be improved.

In a third aspect, the present application provides a slice service processing method, corresponding to the slice service processing method in the first and second aspects, set forth from the perspective of an operator node. The method comprises the following steps: the operator node receives a service fee from the blockchain; the service fee is sent when the test of the slice service is written into the blockchain through information, and is paid by the tenant node for the slice service provided by the operator node; and the operator node activates slicing service according to interface information of the tenant node in the blockchain and provides the slicing service for the tenant node. Therefore, when the operator node activates the slicing service, the service fee can be obtained, the cheating by the tenant node is avoided, and the slicing service provided by the operator node obtained by the tenant node can be ensured to pass the test, namely, the slicing service has the service capability claimed by the operator node, and the cheating by the operator node is avoided.

In one embodiment, an operator node receives a service fee from a blockchain, comprising: the operator node receives payment credentials from the tenant contract; the payment certificate is transmitted by calling the tenant contract when the written test passing information in the slice contract is activated; the test passing information is used for indicating that the slicing service provided by the operator node is selected to pass by the tenant node; the payment credentials are used to instruct the tenant node to pay evidence to the operator node for a service fee pre-stored for the slicing service.

In one embodiment, an operator node provides a slice service to a tenant node according to interface information of the tenant node in a blockchain, including: and providing slicing service to the tenant nodes according to tenant contracts, wherein the tenant contracts comprise interface information of the tenant nodes.

In one embodiment, the slice service processing method further comprises, before the operator node receives the service fee from the blockchain: the operator node updates an external test interface of the slicing service into an address of a test node according to the test request information in the slicing contract; the test request information comprises the address of the test node; the operator node provides slicing service to the test node by using the external test interface.

In one embodiment, the slice service processing method further comprises, before the operator node receives the service fee from the blockchain: the operator node updates an external test interface of the slicing service into an address of a notarized third party node according to the test request information in the slicing contract; the test request information comprises an address of a notarized third party node; the operator node provides slicing service to the notarized third party node by utilizing the external test interface. Therefore, the notarization third party node can use the slicing service to test the slicing service, and the testing efficiency is improved.

In one embodiment, the slice service processing method further comprises, before the operator node receives the service fee from the blockchain: the operator node deploys slicing services requested by the tenant node according to a tenant contract, wherein the tenant contract also comprises information of slicing services selected by the tenant node, service fees paid by the operator node and the tenant node for the slicing services; the operator node defines a slicing service, an external interface of the slicing service, a resource effectiveness test mode of the slicing service and decision parameters passing the test in the slicing contract; the external interfaces of the slice service comprise an external use interface and an external test interface.

In a fourth aspect, the present application provides a slice service processing apparatus, comprising:

a determination unit for verifying whether the slice service has a service capability of the slice service purported to be provided by the operator node;

a writing unit for writing test passing information of the slice service into the blockchain when the slice service has a service capability of the slice service purported to be provided by the operator node; the test pass information of the slice service is used to activate the slice service to the tenant node and pay a service fee to the operator node, the service fee paid by the tenant node for providing the slice service to the operator node.

In one embodiment, the determining unit is further configured to determine whether the slice service passes the test according to a test result and a decision parameter of the slice service passing the test in the slice contract, where the test result is used to indicate a service capability of the slice service provided by the operator node.

In one embodiment, the writing unit is further configured to write test passing information of the slice service into the slice contract; the test passing information is specifically used for activating a slicing contract to call a tenant contract to send a payment certificate to an operator node and sending a notification message to the tenant node; the payment voucher is evidence that the slice contract calls the tenant contract to pay the service fee to the operator node; the notification message is used to notify the tenant node that the operator node has activated the slicing service.

In one embodiment, the apparatus further comprises: and the receiving unit is used for receiving a test result, wherein the test result is obtained by the monitoring node monitoring the slicing service provided by the operator node to the test node.

In one embodiment, the apparatus further comprises: the selecting unit is used for selecting a test node from nodes participating in blockchain consensus by utilizing a random selection algorithm before the receiving unit receives the test result;

The notification unit is used for notifying the test node to write test request information into the slicing contract according to an external test interface and a resource effectiveness test mode defined by the operator node for slicing service in the slicing contract; the test request information includes an address of the test node, and the test request information is used for indicating the operator node to provide slicing service for the test node.

In one embodiment, the selecting unit is further configured to verify whether the random numbers respectively published in the plurality of nodes match with the hash values previously respectively published, where the hash values are obtained by performing hash operation by using the random numbers of the nodes;

the selection unit is further configured to determine a test node from the matched plurality of nodes using a mapping operation. The mapping operation may include a modulo operation; the method comprises the steps that a main node obtains a modular operation value through modular operation, and a test node is determined from a plurality of matched nodes according to the modular operation value, wherein the modular operation value is obtained by carrying out modular operation on N through a combined hash value, the combined hash value is obtained by carrying out combined hash operation through random numbers of the plurality of matched nodes, and N is the number of the plurality of nodes.

In one embodiment, the random numbers and hash values published by each of the plurality of nodes are recorded in a slice contract. Alternatively, the joint hash value and N may be recorded in the slice contract when the mapping operation is a modulo operation.

In one embodiment, the writing unit is further configured to write test request information into the slice contract, where the test request information includes an address of the notarized third party node; the receiving unit is also used for obtaining a test result by using the slicing service provided by the operator node; the test results are used to indicate the service capabilities of the slice services provided by the operator node to the notarized third party node.

In one embodiment, the slice contract is also used to invoke a directory contract, updating the slice service into the rented slice service in the directory contract.

In a fifth aspect, the present application provides a slice service processing apparatus, comprising:

a receiving unit for receiving a notification message from the blockchain, the notification message being transmitted when the test passing information of the slice service is written into the blockchain, for indicating that the operator node has activated the slice service; the slicing service is provided by an operator node selected by the tenant node;

and the response unit is used for responding to the notification message and using the slicing service provided by the operator node.

In one embodiment, the receiving unit is further configured to receive a notification message from the tenant contract, where the notification message is specifically a test passing information of the slice service, and when the test passing information is written into the slice contract, the slice contract is activated to invoke the tenant contract to send.

In one embodiment, the response unit is further configured to use the slice service provided by the operator node according to an external use interface of the slice service in the slice contract in response to a notification message.

In one embodiment, the apparatus further comprises: a selection unit for selecting an operator node providing a slice service according to a directory contract including information of the slice service provided by each operator node maintaining the blockchain before the receiving unit receives the notification message from the blockchain;

and the determining unit is used for determining the tenant contract, wherein the tenant contract comprises interface information of the tenant node, information of slicing services selected by the tenant node, an operator node and service fees paid by the tenant node for the slicing services.

In one embodiment, the selecting unit is further configured to query whether a slice directory contract includes information of each slice service that has been deployed by each operator node, where the slice directory contract includes a required slice service;

the selecting unit is further configured to select an operator node that provides a slicing service, if any;

if not, the selection unit is further configured to query whether the operator node in the resource directory contract has a service capability of providing the slicing service; the selection unit is further configured to select an operator node having a service capability for providing the slicing service if the operator node in the resource directory contract has the service capability for providing the slicing service.

In a sixth aspect, the present application provides a slice service processing apparatus, comprising:

a receiving unit for receiving a service fee from the blockchain; the service fee is sent when the test of the slice service is written into the blockchain through information, and is paid by the tenant node for the slice service provided by the operator node;

and the providing unit is used for activating the slicing service according to the interface information of the tenant node in the blockchain and providing the slicing service for the tenant node.

In one embodiment, the receiving unit is further configured to receive payment credentials from the tenant contract; the payment certificate is transmitted by calling the tenant contract when the written test passing information in the slice contract is activated; the test passing information is used for indicating that the slicing service provided by the operator node is selected to pass by the tenant node; the payment credentials are used to instruct the tenant node to pay evidence to the operator node for a service fee pre-stored for the slicing service.

In one embodiment, the providing unit is further configured to provide a slicing service to the tenant node according to a tenant contract, where the tenant contract includes interface information of the tenant node.

In one embodiment, the apparatus further comprises: the updating unit is used for updating the external test interface of the slice service into the address of the test node according to the test request information in the slice contract before the receiving unit receives the service fee from the blockchain; the test request information comprises the address of the test node; the providing unit is also used for providing slicing service for the test node by utilizing the external test interface.

In one embodiment, the updating unit is further configured to update, before the receiving unit receives the service fee from the blockchain, the external test interface of the slice service to an address of the notarized third party node according to the test request information in the slice contract; the test request information comprises the address of the notarized third party node; the providing unit is also used for providing slicing service for the notarized third party node by utilizing the external test interface.

In one embodiment, the apparatus further comprises: the deployment unit is used for deploying the slicing service requested by the tenant node according to the tenant contract before the receiving unit receives the service fee from the blockchain, wherein the tenant contract also comprises information of the slicing service selected by the tenant node, an operator node and the service fee paid by the tenant node for the slicing service;

the definition unit is used for defining slice service, an external interface of the slice service, a resource effectiveness test mode of the slice service and decision parameters passing the test in the slice contract; the external interfaces of the slice service comprise an external use interface and an external test interface.

In a seventh aspect, the present application provides a communication device comprising a processor; the processor is configured to verify whether the slice service has a service capability of the slice service purported to be provided by the operator node;

The processor is further configured to write test passing information for the slice service into the blockchain when the slice service has a service capability of the slice service purported to be provided by the operator node; the test pass information of the slice service is used to activate the slice service to the tenant node and pay the service fee to the operator node, the service fee being paid by the tenant node for providing the slice service to the operator node.

In one embodiment, the processor is further configured to determine whether the slice service passes the test according to a test result and a decision parameter of the slice service passing the test in the slice contract, where the test result is used to indicate a service capability of the slice service provided by the operator node.

In one embodiment, the processor is further configured to write test passing information for the slicing service into the slicing contract; the test passing information is specifically used for activating a slicing contract to call a tenant contract to send a payment certificate to an operator node and sending a notification message to the tenant node; the payment voucher is evidence that the slice contract calls the tenant contract to pay the service fee to the operator node; the notification message is used to notify the tenant node that the operator node has activated the slicing service.

In one embodiment, the communication device further comprises a communication interface; the communication interface is used for receiving a test result, wherein the test result is that the monitoring node monitors a slice service provided by the operator node to the test node.

In one embodiment, the processor is further configured to select the test node from the nodes participating in blockchain consensus using a random selection algorithm before the communication interface receives the test result; the processor is also used for notifying the test node to write test request information into the slicing contract according to an external test interface and a resource validity test mode defined by the operator node for slicing service in the slicing contract; the test request information comprises an address of a test node, and the test request information is used for indicating an operator node to provide slicing service for the test node.

In one embodiment, the processor is further configured to verify whether the random numbers respectively published in the plurality of nodes match with the hash values previously respectively published, where the hash values are obtained by performing hash operations by using the random numbers of the nodes; the processor is also configured to determine a test node from the matched plurality of nodes using a mapping operation. The mapping operation may include a modulo operation, the processor may obtain a modulo operation value by the modulo operation, and determine a test node from the matched plurality of nodes according to the modulo operation value, wherein the modulo operation value is obtained by performing the modulo operation on N by a joint hash value obtained by performing the joint hash operation using random numbers of the matched plurality of nodes, and N is a number of the plurality of nodes.

In one embodiment, the random number and hash value issued by each of the plurality of nodes are recorded in a slice contract. Optionally, the joint hash value and N when the mapping operation is a modulo operation may be recorded in a slice contract.

In one embodiment, the processor is further configured to write test request information into the slice contract, where the test request information includes an address of the notarized third party node; the processor is further configured to obtain a test result using the slice service provided from the operator node; the test results are used to indicate the service capabilities of the slice services provided by the operator node to the host node.

In an eighth aspect, the present application provides a communication device comprising a processor and a communication interface; the communication interface is used for receiving a notification message from the blockchain, wherein the notification message is sent when the test passing information of the slice service is written into the blockchain and is used for indicating that the operator node has activated the slice service; the slicing service is provided by an operator node selected by the tenant node; the processor is configured to use the slicing service provided by the operator node in response to the notification message.

In one embodiment, the communication interface is further configured to receive a notification message from the tenant contract, where the notification message is specifically a test passing information of the slice service, and when the test passing information is written into the slice contract, the slice contract is activated to invoke the tenant contract to send the notification message.

In one embodiment, the processor is further configured to use the slicing service provided by the operator node in response to the notification message according to an external use interface of the slicing service in the slicing contract.

In one embodiment, the processor is further configured to select an operator node that provides slicing services according to a directory contract including information for maintaining slicing services provided by each operator node of the blockchain before the communication interface receives a notification message from the blockchain;

the processor is further configured to determine a tenant contract, where the tenant contract includes interface information of a tenant node, and information of a slicing service selected by the tenant node, an operator node, and a service fee paid by the tenant node for the slicing service.

In one embodiment, the processor is further configured to query a slice directory contract for the presence of a desired slice service, where the slice directory contract includes information about each slice service that has been deployed by each operator node;

The processor is further configured to select an operator node that provides slicing services, if any;

if not, the processor is further configured to query whether the operator node in the resource directory contract has a service capability for providing the slicing service; the processor is further configured to select an operator node having a service capability to provide the slicing service if the operator node has the service capability to provide the slicing service in the resource directory contract.

In a ninth aspect, the present application provides a communications device comprising a processor and a communications interface; the communication interface is used for receiving service fees from the blockchain; the service fee is sent when the test of the slice service is written into the blockchain through information, and is paid by the tenant node for the slice service provided by the operator node; the processor is used for activating slicing service and providing slicing service for tenant nodes according to interface information of the tenant nodes in the blockchain.

In one embodiment, the communication interface is further for receiving payment credentials from a tenant contract; the payment certificate is transmitted by calling the tenant contract when the written test passing information in the slice contract is activated; the test passing information is used for indicating that the slicing service provided by the operator node is selected to pass by the tenant node; the payment credentials are used to instruct the tenant node to pay evidence to the operator node for a service fee pre-stored for the slicing service.

In one embodiment, the processor is further configured to provide a slicing service to the tenant node according to a tenant contract, where the tenant contract includes interface information of the tenant node.

In one embodiment, the processor is further configured to update the external test interface of the slice service to an address of the test node according to the test request information in the slice contract before the communication interface receives the service fee from the blockchain; the test request information comprises the address of the test node; the processor is also configured to provide slicing services to the test nodes using the external test interface.

In one embodiment, the processor is further configured to update the external test interface of the slice service to an address of a notarized third party node according to the test request information in the slice contract before the communication interface receives the service fee from the blockchain; the test request information comprises an address of a notarized third party node; the processor is also configured to provide a slice service to the notarized third party node using the external test interface.

In one embodiment, the processor is further configured to deploy the slicing service requested by the tenant node according to a tenant contract before the communication interface receives the service fee from the blockchain, wherein the tenant contract further includes information of the slicing service selected by the tenant node, an operator node, and a service fee paid by the tenant node for the slicing service;

The processor is also used for defining a slicing service, an external interface of the slicing service, a resource effectiveness test mode of the slicing service and decision parameters passing the test in the slicing contract; the external interfaces of the slice service comprise an external use interface and an external test interface.

In a tenth aspect, the present application provides a computer readable storage medium storing a computer program which, when run on a computer, causes the computer to perform the method as described in the first aspect, or to perform the method as described in the second aspect, or to perform the method as described in the third aspect.

Drawings

Fig. 1 is a schematic structural diagram of a slice service processing system according to an embodiment of the present application;

FIG. 2 is a schematic diagram of another slice service processing system according to an embodiment of the present application;

FIG. 3 is a block chain architecture diagram according to an embodiment of the present application;

FIG. 4 is a schematic diagram of a slice management architecture according to an embodiment of the present application;

fig. 5 is a schematic diagram of an operator slice management system according to an embodiment of the present application;

fig. 6a is a schematic flow chart of a slice service processing method according to an embodiment of the present application;

Fig. 6b is a flowchart of another slice service processing method according to an embodiment of the present application;

FIG. 6c is a flowchart illustrating another slice service processing method according to an embodiment of the present application;

fig. 7a is a schematic flow chart of another slice service processing method according to an embodiment of the present application;

fig. 7b is a schematic flow chart of another slice service processing method according to an embodiment of the present application;

FIG. 8 is a schematic flow chart of a random selection of test nodes according to an embodiment of the present application;

FIG. 9 is a schematic flow chart of a slice service test according to an embodiment of the present application;

fig. 10a is a schematic flow chart of another slice service processing method according to an embodiment of the present application;

fig. 10b is a flowchart of another slice service processing method according to an embodiment of the present application;

fig. 11 is a schematic structural diagram of a slice service processing apparatus according to an embodiment of the present application;

fig. 12 is a schematic structural diagram of another slice service processing apparatus according to an embodiment of the present application;

fig. 13 is a schematic structural diagram of yet another slice service processing apparatus according to an embodiment of the present application;

fig. 14 is a schematic structural diagram of a communication device according to an embodiment of the present application.

Detailed Description

In order to better understand the slice service processing method provided by the embodiment of the present application, a description is first given of a scenario to which the embodiment of the present application is applicable.

The embodiment of the application can be applied to scenes such as network slice renting and the like. Referring to fig. 1, fig. 1 is a schematic structural diagram of a slice service processing system according to an embodiment of the present application, and a network slice leasing scenario according to an embodiment of the present application may be the slice service processing system shown in fig. 1. The slice service processing system may include, but is not limited to, one or more tenant nodes, one or more operator nodes, such as one tenant node, one operator node for example in fig. 1. The number and configuration of the devices shown in fig. 1 are for example and not intended to limit embodiments of the present application. The tenant node can be used for renting slicing service provided by the operator node, and the operator node can be used for providing slicing service for the tenant node; the operator node may also be used for testing the slicing service, in which case the operator node for testing the slicing service may be referred to as a test node; the operator node may also be configured to monitor the test result of the slice service, where the operator node configured to monitor the test result of the slice service may be referred to as a monitoring node; the operator node may also be configured to notify the test node to perform a test and determine whether the slice service passes the test according to the test result monitored by the monitor node, and the operator node performing these related operations may be referred to as a master node.

Referring to fig. 2, fig. 2 is a schematic structural diagram of another slice service processing system according to an embodiment of the present application, where the network slice leasing scenario according to the embodiment of the present application may also be the slice service processing system shown in fig. 2. The functions of the tenant node and the operator node may be as shown in fig. 1, where the slice service processing system may further include a notarized third party node, which may be a device managed by an organization or an organization other than the blockchain node such as the operator node, and the notarized third party node may be used to test the slice service and determine whether the slice service passes the test, that is, execute the related functions of the master node, the test node, and the listening node in the slice service processing system shown in fig. 1. For convenience of explanation, unless otherwise specified, the slice service processing method according to the embodiment of the present application may be described from the perspective of a tenant node, an operator node, and a verification node, where the verification node may be a master node in fig. 1 or a notarized third party node in fig. 2, so as to perform corresponding operations. In addition, in the embodiment of the present application, the tenant node and the operator node are actually blockchain nodes, and the different naming is for convenience of explanation and distinguishing different operations, and the method described in the embodiment of the present application is not limited.

In order to facilitate an understanding of the disclosed embodiments of the present application, the following two descriptions are provided.

(1) In the embodiment of the present disclosure, the scenario is illustrated by taking the scenario of an NR network in a wireless communication network as an example, and it should be noted that the solution in the embodiment of the present disclosure may also be applied to other wireless communication networks, and the corresponding names may also be replaced by names of corresponding functions in other wireless communication networks.

(2) The disclosed embodiments of the application will present various aspects, embodiments, or features of the application around a system comprising a plurality of devices, components, modules, etc. It is to be understood and appreciated that the various systems may include additional devices, components, modules, etc. and/or may not include all of the devices, components, modules etc. discussed in connection with the figures. Furthermore, combinations of these schemes may also be used.

Next, in order to facilitate understanding of the disclosed embodiments of the present application, the following briefly describes the main concepts to which the embodiments of the present application relate.

1. Network slice and slice services

Network slicing refers to a physical network being divided into each of a plurality of virtual networks, each virtual network being customized and optimized according to different types of application scenarios or requirements of different tenants.

Network slicing is also an independent end-to-end logical network running on a shared physical infrastructure. Operators can efficiently schedule physical network resources on physical infrastructure shared by a plurality of operators to network slices through a virtualization technology according to different application scenes or different demands of tenants, so as to provide corresponding services for corresponding application scenes or tenants. Thus, capital expenditure and operating costs are advantageously reduced.

Among other virtualization technologies, network function virtualization (Network Functions Virtualization, NFV) and software defined networking (Software Defined Network, SDN). NFV techniques can be used to virtualize the physical network resources required for extraction to eliminate the reliance of the physical network resources on dedicated hardware, facilitating flexible creation of network slices. SDN technology may be used to simplify network management by separating the control plane from the data plane and by logically centralizing the network, introducing programmability and open network access, facilitating operators to provide different services for multiple tenants with different needs on a shared physical infrastructure.

Network slicing may support diverse requirements such as enhanced mobile bandwidth connectivity (Enhanced Mobile Broadband, emmbb), large machine type communications (massive Machine Type of Communication, mctc), or high reliability low latency communications (Ultra-relaible and Low Latency Communication, ul lc), among others.

In the embodiment of the application, the network slice can be simply referred to as a slice, and the slice service refers to a service provided by the network slice rented by the tenant node from the operator node.

2. Block, blockchain, and blockchain link points

The block is used as a data structure to store transaction information. Referring to fig. 3, fig. 3 is a schematic block diagram of a block chain according to an embodiment of the present application, and as shown in fig. 3, a block may include a block header and a block body. The block header is used for storing a time stamp, a hash value of a transaction, a hash value of a previous block and other information; the block is used for storing transaction records, for example, the transaction records can be transfer records, intelligent contract records, clearing records, internet of things data records, and the like. The content of the transaction records may vary from application scenario to application scenario.

The blockchain, as shown in fig. 3, is composed of a plurality of blocks connected in sequence in a chain structure. The blockchain as a distributed database has the characteristics of decentralization, non-falsification, traceability and transparency. Blockchains can be divided into three broad categories based on application scope: public chains, private chains, and federation chains.

Blockchain nodes refer to nodes that participate in a blockchain network, which may be identified by blockchain accounts, such as by private key-based addresses. The information sent by the blockchain node is signed by a private key to ensure the security of transactions in the blockchain network. The blockchain link points in embodiments of the present application include tenant nodes and operator nodes, wherein the operator nodes may also participate in maintaining blockchain networks, such as participating in blockchain consensus to maintain blockchain networks, through blockchain processing functions (BlockChain Handling Function, BCHF). The carrier node may also be used to obtain information in or write information to the blockchain, in which case the carrier node may also be referred to as a miner node.

3. Consensus mechanism in blockchain

The consensus mechanism in the blockchain is used for verifying the information which is wanted to be written into the blockchain through a consensus algorithm, so that the synchronization of the information stored in the local blockchain copy of each blockchain node in the blockchain network is ensured.

Among them, the consensus algorithm can be divided into two types, the first is a consensus algorithm based on proof, for example: proof of Work, poW, proof of equity, delegate stock equity (Delegated Proof of Stake, DPoS), greedy heaviest observable subtree algorithm (he Greedy Heaviest-assisted Sub-Tree, ghest), etc., which requires blockchain nodes to submit solutions to a problem, the blockchain node that first solved the problem can package information into blocks that are added to the blockchain, typically for use in public chains; the second is a consensus algorithm that solves the bayer problem using conventional fault-tolerant techniques in the distributed computing domain, such as: practical bayer fault tolerance algorithms (Practical Byzantine Fault Tolerance, PBFT), are commonly used in federation chains.

In the embodiment of the application, the main node determines the test node through a random selection algorithm, and the process of testing the slice service by the test node and the monitoring node belongs to the process of achieving consensus of the block chain node in the consensus mechanism aiming at the service capability of the slice service. The process that the notarization third party node writes the test result of the slicing service into the slicing contract belongs to the process that the block chain node in the consensus mechanism agrees with the act of determining the test result of the slicing service aiming at the notarization third party node.

4. Intelligent contract

A smart contract refers to a script program that can be automatically executed on a computer system when certain conditions are met. Many functions may be performed by functions in the smart contracts, such as securities exchanges, financial data records, crowd funding, etc.

In the embodiment of the application, the intelligent contract is combined with the blockchain, the intelligent contract is permanently stored in the block of the blockchain, a contract address can be generated according to the storage position of the intelligent contract in the block of the blockchain, and the blockchain node can deploy or call the intelligent contract by generating a transaction containing a contract code or a call instruction and the contract address.

In the embodiment of the application, the intelligent contract can be used for publishing the information of the slicing service provided by each operator node, and the intelligent contract can be called a directory contract at the moment; the intelligent contract can also be used for publishing interface information of the tenant node, information of slicing service selected by the tenant node and an operator node, and storing service fees paid by the tenant node for the slicing service, and the intelligent contract can be called as a tenant contract at this time; the intelligent contract can also be used for storing slicing services provided by the operator node, external interfaces of the slicing services, a resource effectiveness test mode of the slicing services, judgment parameters of test passing and information about whether the slicing services pass or not, and can be called as slicing contract.

Referring to fig. 4, fig. 4 is a schematic diagram of a slice management architecture according to an embodiment of the present application. The slice management architecture includes a network layer, network slice management, blockchain, and application layer.

The network layer comprises physical network resources and virtualized resources. The operator node virtualizes the shared physical network resources using virtualization techniques to form virtualized resources that may be used to generate the slices.

Network slice management, including a plurality of operator nodes. Each operator node runs an operator slice management system through which a network slice management platform is formed together to manage network slices. Referring to fig. 5, fig. 5 is a schematic diagram of an operator slice management system according to an embodiment of the present application, where the slice management system may include the following functional entities: communication services management function (Communication Service Management Function, CSMF) 501, slice management function (Network Slice Management Function, NSMF) 502, sub-slice management function (Network Slice Subnet Management Function, NSSMF) 503, management and orchestration (Management and Orchestration, MANO) 504. Wherein the CSMF501 is used to convert the tenant's requirement information into service level agreement (Service Level Agreement, SLA) based information suitable for slicing; NSMF502 is used to select an appropriate plurality of sub-slices based on SLA information; NSSMF503 is configured to apply for resources of the above-mentioned multiple sub-slices from physical network resources, and perform lifecycle management on each sub-slice, for example, design and process the sub-slices; the network, storage resources, etc., upon which each sub-slice depends are deployed through MANO 504. The plurality of sub-slices form a slice, and cooperate to provide slice service for tenant nodes.

A blockchain includes a plurality of blocks storing transaction information. Multiple operator nodes in network slice management are linked by a blockchain and the blockchain is maintained jointly by the multiple operator nodes. The blockchain can be used as a platform for information management and renting of slice services, and is combined with network slice management to form a distributed network slice management platform, so that the efficiency of managing network slices by a plurality of operator nodes is improved.

An application layer comprising a plurality of slices and slice services. And the operator node selects proper slicing according to different requirements of different tenant nodes, and provides corresponding slicing services for the tenant nodes.

In the process that the operator node rents the network slice to the tenant node, there is a trust problem between the operator node and the tenant node, such as a contradiction that the operator node provides service first or the tenant node pays first, specifically, for example, the tenant node cannot obtain the slice service of the service capability claimed by the operator node after providing service fee to the operator node, and is deceived by the operator node, or the operator node provides service fee to the tenant node after providing the slice service, and cannot obtain the service fee paid by the tenant node, and is deceived by the tenant.

The application provides a slice service processing method, which can determine whether slice service passes a test or not according to a test result and a decision parameter of the pass of the slice service test in a slice contract. And when the slice service test is passed, writing test passing information of the slice service into the slice contract, wherein the test passing information is used for activating the slice contract to call the tenant contract to send payment credentials to the operator node and sending notification messages to the tenant node. The method is beneficial to the slicing service of the service capability claimed by the operator node after the service fee is provided, and the tenant node is prevented from being deceived by the operator node. The method is also beneficial to providing slicing service for the tenant node after the service fee is obtained by the operator node, so that the operator node is prevented from being deceptively deceived by the tenant node, and further, the trust problem between the operator and the tenant is effectively solved.

The slicing processing method provided by the application is described below with reference to the accompanying drawings.

Referring to fig. 6a, fig. 6a is a flowchart of a slice service processing method according to an embodiment of the present application, where the slice service processing method is illustrated from the interaction point of a tenant node, an operator node and a verification node, and the verification node may perform the related operations of the master node or the notarized third party node described in fig. 1 and 2. As shown in fig. 6a, the slice service processing method includes, but is not limited to, the following steps:

S401, the verification node verifies whether the slice service has the service capability of the slice service purportedly provided by the operator node; if the slice service does not have the service capability of the slice service purported to be provided by the operator node, then step S402 is performed; if the slice service has the service capability of the slice service purported to be provided by the operator node, performing steps S403 to S407;

s402, the verification node writes the test failing information of the slice service into the blockchain;

s403, the verification node writes test passing information of the slice service into the block chain;

wherein the test pass information of the slice service is used to activate the slice service to the tenant node and pay a service fee to the operator node, the service fee being paid by the tenant node for providing the slice service to the operator node. In one embodiment, the verifying node in step S401 verifies whether the slice service has the service capability of the slice service purported to be provided by the operator node, may include: the verification node determines whether the slice service passes the test or not according to the test result and the decision parameter of the slice service passing the test in the slice contract; wherein the test results are used to indicate the service capabilities of the slice services provided by the operator node. In step S403, the verifying node writes the test passing information of the slice service into the blockchain, which may include: the validation node writes test passing information of the slice service into the slice contract.

S404, receiving a notification message from a blockchain by a tenant node;

the notification message is sent when the test of the slice service is written into the blockchain through information and is used for indicating that the operator node has activated the slice service; the slicing service is provided by an operator node selected by the tenant node.

In one embodiment, the notification message may be specifically that when a test of the slicing service is written to a slicing contract by information, the slicing contract is activated and the tenant contract is invoked to send.

S405, the operator node receives service fees from the blockchain;

in one embodiment, an operator node receives a service fee from a blockchain, may include: the operator node receives payment credentials from the tenant contract; the payment certificate is sent by calling the tenant contract when the written test passing information in the slice contract is activated; the payment credentials are used to instruct the tenant node to pay evidence to the operator node for a service fee pre-stored for the slicing service.

As described in the terminology section above, tenant contracts are the role of tenants in publishing service requirements, making payments, selecting operators, and providing tenant-side interfaces. The interface of the tenant side is used for defining the calling relation between the tenant contract and other contracts, such as slicing contracts. The tenant publishes a service requirement and the fee paid for that service requirement may be referred to as a policy. Accordingly, the service fee paid by the tenant node for the slice service may be a portion deducted from the guard, and thus the guard paid by the tenant in the tenant contract may be at least greater than or equal to the service fee. Alternatively, the tenant contract may define the resources predefined for demand in the bond, the amount that is willing to pay, and the meaning of the bond (the bond must be greater than the amount that is willing to pay, otherwise the contract is not valid). Optionally, the deposit is transferred from the account balance of the tenant to the contract account when the contract is created.

Wherein the guarantees are hosted in the blockchain in the form of intelligent contracts. One way the deposit may be paid directly for a certain slice service; alternatively, the guard may be hosted into the blockchain account by the tenant node requesting any slicing services, in which case the guard may be left unused, rolled back to the tenant, or left in the blockchain account balance. Where blockchain account balance refers to digital property under the smart contract account that is not affiliated with any actual user, but rather in a logical sense, where the smart contract is not invoked by an associated payment transaction, it may be paid to other accounts (including user accounts in the actual sense) through a payment script allowed by the smart contract, or returned to a designated account after a transaction has not occurred prior to a defined expiration time.

In this way, the verification node may determine whether the operator node provides the service capability of the slicing service it claims to be, and if so, if the slicing service test passes, automatically transfer payment to the blockchain account of the operator node in a agreed manner, or provide payment vouchers to the operator node.

S406, the operator node activates slicing service and provides slicing service for the tenant node according to interface information of the tenant node in the blockchain;

in one embodiment, an operator node may provide a slicing service to a tenant node according to a tenant contract; the tenant contract comprises interface information of the tenant node.

S407, responding the notification message by the tenant node, and using the slicing service provided by the operator node.

In one embodiment, the tenant node may include: and the tenant node uses the slicing service provided by the operator node according to the external use interface of the slicing service in the slicing contract.

In the slice service processing method, the verification node verifies whether the slice service has the service capability of the slice service purported to be provided by the operator node, and when the slice service test is passed, the verification node sends service fees to the operator node through the blockchain and sends a notification message to the tenant node to inform the tenant node that the slice service is activated. Thus, when the operator node activates the slicing service, the service fee can be obtained, and the cheating by the tenant node is avoided.

Referring to fig. 6b, fig. 6b is a flowchart illustrating another slice service processing method according to an embodiment of the present application. The slice service processing method illustrated in fig. 6b is illustrated from the perspective of interaction of the tenant node, the operator node, and the verification node, wherein the verification node may perform the operations related to the master node or the notarized third party node described in fig. 1 and 2. As shown in fig. 6b, the slice service processing method includes, but is not limited to, the following steps:

s101, a verification node determines whether a slice service passes a test or not according to a test result and a decision parameter of the pass of the slice service test in the slice contract; if the slice service test is not passed, executing step S102; if the slice service test passes, steps S103 to S107 are performed;

s102, the verification node writes test failing information of the slice service into a slice contract;

s103, the verification node writes test passing information of the slicing service into the slicing contract;

wherein the test results are used to indicate the service capabilities of the slice services provided by the operator node. The verifying node determines whether the slice service passes the test according to the test result and the decision parameter passing the slice service test in the slice contract, and the determining may include: the verification node determines the service capability parameters of the slice service according to the test result; when the service capability parameter is not less than the decision parameter passed by the slice service test, determining that the slice service test passes; and when the service capability parameter is smaller than the decision parameter which is passed by the slice service test, determining that the slice service test is not passed. The test passing information may include a service capability parameter of the slice service, and correspondingly, the test failing information may also include a service capability parameter of the slice service.

For example, the decision parameters passed by the slice service test include network bandwidth 20M, rate 2.5Mb/s; the service capability parameters of the slice service determined according to the test result comprise network bandwidth 20M and rate 1.7Mb/s of the slice service. It can be seen that the service capability parameter of the slice service is smaller than the decision parameter, indicating that the slice service test is not passed.

As another example, decision parameters that the slice service test passes include network bandwidth 20M, rate 2.5Mb/s; the service capability parameters of the slice service determined according to the test result comprise network bandwidth 20M and rate 2.7Mb/s of the slice service. It can be seen that the service capability parameter of the slice service is not less than the decision parameter, indicating that the slice service test passes.

In step S103, the verification node writes test passing information of the slice service into the slice contract, where the test passing information is used to activate the slice contract to invoke the tenant contract to send payment credentials to the operator node and send notification messages to the tenant node. Wherein the payment credential is evidence that the slice contract invokes the tenant contract, paying a service fee to the operator node, the service fee paid by the tenant node for providing the slice service to the operator node; the notification message is used to notify the tenant node that the operator node has activated the slicing service. Thus, when the operator node activates the slicing service, the service fee can be obtained, and the cheating by the tenant node is avoided.

The process of using the test passing information to activate the slice contract to call the tenant contract to send the payment credential and the notification message may be: the slice contract calls the tenant contract to send the payment certificate and the notification message based on a calling interface between the slice contract and the tenant contract. The triggering condition of the calling interface may be that the above test passing information is written in the slice contract, and the test passing information may include the above service capability parameter, and/or an identifier for indicating that the test passes, etc.

In one embodiment, the test pass information is further used to activate a slice contract call directory contract to update the slice service into a rented slice service in the directory contract. The embodiment is beneficial to publishing that the slicing service provided by the operator node is provided for the tenant node, so that other tenant nodes are informed that the slicing service is used, repeated selection of the slicing service by the other tenant nodes is avoided, and further, the efficiency of selecting proper slicing service by the other tenant nodes is improved.

S104, receiving a notification message from a tenant contract by a tenant node;

s105, the operator node receives payment credentials from tenant contracts;

S106, the operator node provides slicing service for the tenant node according to the tenant contract;

the process of providing slicing service to the tenant node by the operator node according to the tenant contract may include: the operator node obtains interface information of the tenant node from the tenant contract; and providing the slicing service for the tenant node by utilizing the interface information of the tenant node.

S107, the tenant node responds to the notification message, and uses the slicing service provided by the operator node according to the external use interface of the slicing service in the slicing contract;

in one embodiment, before the tenant node in S104 receives the notification message from the tenant contract, the slice service processing method further includes: the tenant node selects an operator node providing a slicing service according to the directory contract, and determines the tenant contract. The directory contract comprises information of slicing services provided by each operator node for maintaining the blockchain; the tenant contract comprises interface information of the tenant node, information of slicing service selected by the tenant node, an operator node and service fees paid by the tenant node for the slicing service. Therefore, when the test passing information is written in the slicing contract, the slicing contract is activated to call the tenant contract to pay the service fee to the corresponding operator node, and the operator node is prevented from being deceptively deceived by the tenant node.

In this embodiment, the directory contracts may include a slice directory contract and a resource directory contract; the slice directory contract includes information of each slice service that each operator node has deployed, including rented slice services and non-rented slice services, including slice services that pass testing and slice services that do not pass testing; the resource directory contract comprises service capability which can be provided by the operator node, and the slicing service corresponding to the service capability is not deployed by the operator node. The tenant node selects an operator node providing slicing service according to the directory contract, and may include: the tenant node inquires whether an operator node capable of providing the required slicing service exists in the slicing directory contract; if the operator nodes capable of providing the required slicing service exist in the slicing directory contract, determining the selected operator nodes from the operator nodes capable of providing the required slicing service by the tenant nodes; if the operator node capable of providing the required slicing service does not exist in the slicing directory contract, the tenant node inquires whether the operator node capable of providing the service capability of the slicing service exists in the resource directory contract; if so, the tenant node determines a selected operator node from among the operator nodes capable of providing the service capability of the slice service.

The tenant node may invoke the resource directory contract by using the slice directory contract, and execute the operation of querying whether the operator node in the resource directory contract can provide the service capability of the slice service.

Optionally, if the slice service required by the tenant node exists in the slice directory contract, the slice service selected by the tenant node is a slice service already deployed by the operator node, including a slice service that passes the test or a slice service that does not pass the test. If the slice directory contract does not contain the required slice service, the slice service selected by the tenant node is the slice service requested by the operator node deployed or newly built according to the tenant contract, and in addition, after the operator node deploys or newly builds the slice service, an external interface of the slice service, a resource effectiveness test mode of the slice service and a decision parameter passing the test are defined in the slice contract. The tenant contract comprises information of slicing services required by tenant nodes; the operations associated with the operator node deploying or creating the slice service may be performed using the operator slice management system shown in fig. 5. After the operator node deploys or newly builds the slice service, the service capability of the slice service needs to be unpublished in the resource directory contract, so that the service capability of the slice service is prevented from being repeatedly queried in the resource directory contract by other tenant nodes.

In one embodiment, if the slicing service selected by the tenant node is a slicing service that has been deployed and passed by the test by the operator node, after the tenant node determines the tenant contract, the tenant node may be activated to invoke the tenant contract to send the payment certificate to the operator node and send the notification message to the tenant node, so as to perform the operations related to S104 to S107 described below.

In another embodiment, if the slice service selected by the tenant node is a slice service that has been deployed and has not been tested by the operator node, the slice service needs to be tested to perform the related operations of steps S101 to S107.

In another embodiment, if the slicing service selected by the tenant node is a slicing service newly created or deployed by the operator node, the slicing service also needs to be tested to execute the related operations of steps S101 to S107.

That is, the slice service processing method described in fig. 6b is mainly directed to the processing of an untested (or called an existing slice that has not been subjected to a valid test) or a newly created slice service (or called a new slice).

Referring to fig. 6c, fig. 6c is a flow chart of another slice service processing method according to an embodiment of the present application, where fig. 6c is different from the slice service processing method shown in fig. 6b in that fig. 6c further shows smart contracts on a blockchain, including slice contracts, directory contracts, and tenant contracts, so that links among authentication nodes, operator nodes, tenant nodes, and smart contracts on the blockchain can be more clearly shown. As shown in fig. 6c, the validation node may write information to the slice contract as to whether the slice service test passed; the test passing information can be used for activating a slicing contract to call a tenant contract to provide payment credentials for an operator node, and sending a notification message to the tenant node to inform the tenant node that the slicing service is activated; the test pass information may also be used to activate slice contract calls and update directory contracts.

Therefore, the slice service processing method disclosed by the embodiment of the application is beneficial to each operator node to record own slice service on the blockchain for the tenant to inquire by using the directory contract, and correspondingly, the tenant node can select the operator node providing the corresponding slice service through the directory contract or apply for the slice service to the corresponding operator node, so that the operator node prepares the slice service through the slice management system and defines the related information of the slice service in the slice contract. In addition, when the slicing service test passes, the embodiment of the application sends the payment certificate to the operator node, and pays the service fee of the slicing service to the operator node, thereby being beneficial to ensuring that the tenant obtains the slicing service with the service capability claimed by the operator node, avoiding the tenant node from being deceptively deceived, being beneficial to the operator node to provide the service for the tenant node after obtaining the service fee, avoiding the operator node from being deceived, and solving the trust problem between the operator node and the tenant node.

Referring to fig. 7a, fig. 7a is a flowchart of another slice service processing method according to an embodiment of the present application, where the slice service processing method shown in fig. 7a is different from the slice service processing method shown in fig. 6b in that the slice service processing method shown in fig. 7a further describes the related operations of the slice service test in conjunction with the slice service processing system shown in fig. 1 before steps S101 to S107 described in fig. 6 b. I.e. the master node in fig. 7a may perform the relevant operations of the authentication node in the slice service processing method described above with reference to fig. 6 b. Specifically, the slice service processing method shown in fig. 7a includes, but is not limited to, the following steps:

s201, a main node selects a test node from nodes participating in blockchain consensus by using a random selection algorithm;

wherein, the random selection algorithm is a method for randomly selecting the test node. The security requirements satisfied by the random selection algorithm may include: the random selection algorithm can ensure that the test node selection process is transparent, and all nodes participating in the blockchain consensus can acquire the related information of the test node selection process; the random selection algorithm can also ensure the randomness of the selection result of the test node, but not subjectively selected by malicious nodes participating in block consensus; and further, fairness and effectiveness of the test node selection process can be guaranteed.

In one embodiment, the master node selecting a test node from the nodes participating in blockchain consensus using a random selection algorithm may include: the method comprises the steps that a master node verifies whether random numbers published by each of a plurality of nodes are matched with hash values published by each of the nodes in advance, wherein the hash values are obtained by the nodes through hash operation by utilizing the random numbers of the nodes; the master node determines a test node from the matched plurality of nodes using a mapping operation. Alternatively, the mapping operation may comprise a modulo operation; the method comprises the steps that a main node obtains a modular operation value through modular operation, and a test node is determined from a plurality of matched nodes according to the modular operation value, wherein the modular operation value is obtained by carrying out modular operation on N through a combined hash value, the combined hash value is obtained by carrying out combined hash operation through random numbers of the plurality of matched nodes, and N is the number of the plurality of nodes. The random numbers and hash values, and the joint hash values and N published by the nodes are recorded in the slice contract.

For example, referring to fig. 8, fig. 8 is a schematic flow chart of a test node random selection according to an embodiment of the present application. As shown in FIG. 8, all nodes participating in blockchain consensus include blockchain node 0, blockchain nodes 1, …, blockchain node N-1, for a total of N blockchain nodes. All of the blockchain nodes described above may in turn become master nodes, and the description below uses blockchain node i as the master node.

The process of the master node selecting the test node using the random selection algorithm may include: each blockchain node hashes its own random number by a hash function, e.g., blockchain node 0 uses its own random number x ₀ Performing hash operation to obtain a hash value y ₀ ＝Hash(x ₀ ) Similarly, the hash value of the blockchain node 1 can be obtained to be y ₁ Hash value y of …, blockchain node N-1 _N-1 The method comprises the steps of carrying out a first treatment on the surface of the Block chain node 0 through block chain node N-1 respectively publish their own hash values y ₀ 、y ₁ 、…、y _N-1 In the blockchain mode, the published hash value is distributed on the blockchain through transactions to ensure non-tamperability and traceability; after all blockchain nodes have published their own hash values, blockchain node 0 through blockchain node N-1 each publish their own random number x ₀ 、x ₁ 、…、x _N-1 。

The master node collects hash values and random numbers published by all the blockchain nodes and verifies whether the random numbers published by each node are matched with the hash values or not; and calculates the joint Hash value of the random numbers of all the matched nodes as Hash (x ₀ ||x ₁ ||...||x _N-1 ) The combined Hash value is modulo-operated on N, i.e. Hash (x ₀ ||x ₁ ||...||x _N-1 ) mod n, a modulo operation value is obtained. And the master node determines the nodes with the same labels as the modular arithmetic value as test nodes in all nodes participating in the block chain consensus, and the rest nodes are monitoring nodes.

For example, N is 4, and the nodes participating in blockchain consensus include blockchain node 0, blockchain node 1, blockchain node 2, and blockchain node 3, where blockchain node 3 is the master node. The master node verifies whether the random numbers respectively published by each node are matched with the hash values; and if the verification result finds that the random number published by the block chain node 2 is not matched with the hash value, performing modulo operation on the joint hash value pair 4 of the block chain node 0, the block chain node 1 and the block chain node 3 to obtain a modulo operation value, wherein the modulo operation value is one numerical value of 0, 1, 2 and 3. Taking the modulo operation value of 1 as an example, the master node may determine that the blockchain node 1 is a test node, and that the blockchain node 0 and the blockchain node 1 are listening nodes.

In the above embodiment, the security of the test node selection process is ensured from the cryptography perspective by using the hash function. In addition, through the mode that a plurality of nodes participating in blockchain consensus firstly publish hash values and then publish random numbers, the fact that all nodes cannot randomly change own random numbers after the hash values are published is guaranteed, even if a malicious node is the last node which publishes random numbers, a test node selection result cannot be changed through modifying own random numbers, and therefore the fact that the malicious node determines own random numbers through offline calculation or multiple attempts is avoided, and the probability that the malicious node plays a decisive role in the test node selection process is reduced. In the above embodiment, the random number and the hash value, and the joint hash value and N, which are respectively published by the plurality of nodes, are recorded in the blockchain, which is also beneficial to ensuring the transparency of the disclosure of the test node selection process.

S202, a master node informs a test node to write test request information into a slice contract according to an external test interface and a resource effectiveness test mode defined by an operator node for slice service in the slice contract;

the method comprises the steps that a main node obtains an external test interface and a resource effectiveness test mode defined by an operator node aiming at slicing service in slicing contracts, and sends a notification message to a test node; the notification message may include an external test interface and a resource validity test mode defined by the operator node for the slice service, and the notification message may be used as a basis for determining test request information by the test node; the notification message is also used to notify the test node to write test request information into the slice contract.

S203, the test node writes test request information into the slice contract;

after receiving the notification message from the main node, the test node determines test request information according to an external test interface and a resource validity test mode in the notification message, and writes the test request information into a slicing contract.

The test request information comprises an address of a test node, and the test request information is used for indicating an operator node to provide slicing service for the test node according to the address of the test node. Optionally, the test request information may further include an address of a monitoring node, and after the operator node modifies the interface according to the address of the monitoring node, the monitoring node may monitor a test result of the slice service provided by the operator node to the test node; optionally, the test request information may further include identity information of the test node and the monitoring node, and the operator node may confirm the identity of the node for testing and monitoring the slicing service according to the identity information.

S204, the operator node updates an external test interface of the slicing service into an address of a test node according to the test request information in the slicing contract;

the operator node obtains the address of the test node in the test request information, redirects the external test interface of the slice service to the test node according to the address of the test node, and updates the external test interface of the slice service to the address of the test node.

Optionally, the operator node obtains an address of the monitoring node in the test request information, redirects the external monitoring interface to the monitoring node according to the address of the monitoring node, and updates the external monitoring interface to the address of the monitoring node; the pair of external monitoring interfaces can be used for monitoring the test result of the slicing service provided by the operator node to the test node by the monitoring node.

S205, the operator node provides slicing service for the test node by using the external test interface;

the slicing service provided by the operator node to the test node and the slicing service provided by the operator node to the tenant node after the slicing service test is passed may not be identical. In addition, the slice service needs to be tested on a specific device, so that the operator node provides the pair of external test interfaces for the tenant node, and meanwhile, a virtualized test device needs to be provided, and the slice service provided by the virtualized test device can be called slice test service. For example, as shown in fig. 9, fig. 9 is a schematic flow chart of a slice service test according to an embodiment of the present application. The operator node provides a slice test service deployed by the virtualized test equipment to the test node through the external test interface; the test node receives the slice test service by using the pair of external test interfaces; if the test passes, the operator node may switch to provide the slicing service to the tenant node by using the external use interface, where the slicing service is a slicing service actually deployed by the operator device, similar to the slicing test service.

Wherein the operator node may deploy the virtualized test equipment based on a security assurance Specification (Security Assurance Specification, SCAS) test method. The SCAS test method is a test method for testing whether a network product can provide expected functions in a virtual environment, and requires that an interface related to the network product be deployed before testing. In the above embodiment, the operator node has deployed a virtualized test device and a slice service related interface, where the slice service related interface includes an external test interface and an external monitor interface; the test node may execute the test of whether the slice service provided by the operator node has the purported service capability shown in step S206 by using the SCAS test method through the virtualized test device; the listening node may execute the test result of the slice service provided to the test node by the listening operator node as shown in step S207 through the virtualized test device.

S206, the test node tests the slicing service provided by the operator node;

s207, monitoring a test result of slicing service provided by an operator node to a test node by a monitoring node;

s208, the monitoring node sends the test result to the master node;

S209, the main node receives a test result from the monitoring node;

in one embodiment, there may be a plurality of listening nodes in this embodiment that perform the operations associated with steps S207 and S208, respectively. The monitoring nodes monitor the test results of the slicing service provided by the operator node to the test node respectively, and summarize the respective monitored test results to the master node; the master node gathers test results from the plurality of listening nodes and writes the test results into the slice contract.

S210, the master node determines whether the slice service passes the test according to the test result and the decision parameter of the pass of the slice service test in the slice contract; if the slice service test is not passed, executing step S211; if the slice service test passes, steps S212 to S216 are executed;

s211, the master node writes test failing information of the slice service into a slice contract;

s212, the master node writes test passing information of the slice service into a slice contract;

s213, the tenant node receives a notification message from the tenant contract;

s214, the operator node receives payment credentials from the tenant contract;

s215, the operator node provides slicing service for the tenant node according to the tenant contract;

S216, the tenant node responds to the notification message, and uses the slicing service provided by the operator node according to an external use interface of the slicing service in the slicing contract;

the relevant descriptions of steps S210 to S216 can be referred to in the slice service processing method shown in fig. 6b, and will not be described in detail herein. In the relevant explanation of step S210 to step S212, the relevant operation of the verification node in fig. 6b is performed by the master node.

Referring to fig. 7b, fig. 7b is a flow chart of another slice service processing method according to an embodiment of the present application, where fig. 7b is different from the slice service processing method shown in fig. 7a in that fig. 7b further shows smart contracts on a blockchain, including slice contracts, directory contracts, and tenant contracts, so that relationships among a master node, a test node, an operator node, a tenant node, and the smart contracts on the blockchain can be more clearly shown. As shown in fig. 7b, the test node writes test request information to the slice contract; the operator can provide slicing service for the test node according to the test request information in the slicing contract; the master node writes the information of whether the slice service test passes or not into a slice contract; the test passing information can be used for activating a slicing contract to call a tenant contract to provide payment credentials for an operator node, and sending a notification message to the tenant node to inform the tenant node that the slicing service is activated; the test pass information may also be used to activate slice contract calls and update directory contracts.

It can be seen that the slice service processing method tests whether the slice service provided by the operation node has its purported service capability through the test node and the listening node. The method is beneficial to ensuring that the tenant node uses the slicing service of the service capability claimed by the operator node, and avoiding the tenant node from being deceptively deceived. And the service cost is obtained by the operator node, and the service is provided for the tenant node, so that the operator node is prevented from being deceptively deceived.

Referring to fig. 10a, fig. 10a is a flowchart of another slice service processing method according to an embodiment of the present application, where the slice service processing method shown in fig. 10a is different from the slice service processing method shown in fig. 6b in that the slice service processing method shown in fig. 10a further illustrates a slice service test related operation in conjunction with the slice service processing system shown in fig. 2 before the slice service processing related operation shown in fig. 6 b. That is, the notarized third party node in fig. 10a may perform the operations associated with the authentication node in the slice service processing method described above with respect to fig. 6 b. Specifically, the slice service processing method shown in fig. 10a may include, but is not limited to, the following steps:

s301, determining test request information by a notarization third party node according to an external test interface and a resource validity test mode defined by an operator node for slicing service in slicing contracts;

S302, writing test request information into the slice contract by the notarized third party node through BCHF; wherein the test request information includes an address of the notarized third party node.

S303, the operator node updates an external test interface of the slicing service into an address of a notarized third party node according to the test request information in the slicing contract;

s304, the operator node provides slicing service for the notarized third party node by utilizing an external test interface;

s305, the notarization third party node uses the slicing service provided by the operator node to obtain a test result; the test result is used for indicating the service capability of the slice service provided by the operator node to the notarization third party.

S306, determining whether the slice service passes or not according to the test result and the decision parameter of the slice service passing in the slice contract by the notarization third party node; if the slice service test is not passed, executing step S307; if the slice service test passes, steps S308 to S312 are executed;

s307, the notarized third party node writes the test failing information of the slicing service into the slicing contract;

s308, the notarization third party node writes the test passing information of the slicing service into the slicing contract;

S309, the tenant node receives a notification message from the tenant contract;

s310, the operator node receives payment credentials from tenant contracts;

s311, the operator node provides slicing service for the tenant node according to tenant contracts;

s312, the tenant node responds to the notification message, and uses the slicing service provided by the operator node according to the external use interface of the slicing service in the slicing contract;

the relevant descriptions of steps S306 to S312 can be referred to the relevant content in the slice service processing method shown in fig. 6b, and will not be described in detail here. In the relevant descriptions of steps S306 to S308, the relevant operations of the verification node in fig. 6b are performed by the notarized third party node.

Referring to fig. 10b, fig. 10b is a flowchart of another slice service processing method according to an embodiment of the present application, where fig. 10b is different from the slice service processing method shown in fig. 10a in that fig. 10b further shows smart contracts on a blockchain, including slice contracts, directory contracts, and tenant contracts, so that relationships among notarized third party nodes, operator nodes, tenant nodes, and smart contracts on the blockchain can be more clearly shown. As shown in fig. 10b, the notarized third party node writes test request information to the slice contract; the operator can provide slicing service for the notarized third party node according to the test request information in the slicing contract; the notarization third party node writes the slice service test whether the information passes the slice contract or not; the test passing information can be used for activating a slicing contract to call a tenant contract to provide payment credentials for an operator node, and sending a notification message to the tenant node to inform the tenant node that the slicing service is activated; the test pass information may also be used to activate slice contract calls and update directory contracts.

In the slice service processing method described in fig. 10a and fig. 10b, the notarized third party node tests the slice service provided by the operator node and obtains the test result, and can ensure the security and the validity of the test process through the post-audit, for example, if the slice service used by the tenant node does not have the service capability claimed by the operator node, the notarized third party node needs to be responsible for the test. The method is also beneficial to simplifying the test flow and improving the test efficiency.

Referring to fig. 11, fig. 11 is a schematic structural diagram of a slice service processing apparatus according to an embodiment of the present application. As shown in fig. 11, the slice service processing apparatus 1100 may include: a determination unit 1101, a writing unit 1102, a receiving unit 1103, a selection unit 1104, a notification unit 1105.

A determining unit 1101 for verifying whether the slice service has a service capability of the slice service purported to be provided by the operator node;

in one embodiment, the determining unit 1101 is further configured to determine whether the slice service passes the test according to a test result and a decision parameter of the slice service passing the test in the slice contract, where the test result is used to indicate a service capability of the slice service provided by the operator node.

A writing unit 1102, configured to write test passing information of the slice service into the blockchain when the slice service has a service capability of the slice service purported to be provided by the operator node; the test pass information of the slice service is used to activate the slice service to the tenant node and pay a service fee to the operator node, the service fee paid by the tenant node for providing the slice service to the operator node.

In one embodiment, the writing unit 1102 is further configured to write test passing information of the slice service into the slice contract; the test passing information is specifically used for activating a slicing contract to call a tenant contract to send a payment certificate to an operator node and sending a notification message to the tenant node; the payment voucher is evidence that the slice contract calls the tenant contract to pay the service fee to the operator node; the notification message is used to notify the tenant node that the operator node has activated the slicing service.

In one embodiment, the writing unit 1102 is further configured to write test request information to the slice contract, where the test request information includes an address of the notarized third party node.

And the receiving unit 1103 is configured to receive a test result, where the test result is a test result that the monitoring node monitors a slice service provided by the operator node to the test node.

In one embodiment, the receiving unit 1103 is further configured to obtain a test result by using a slice service provided by the operator node; the test results are used to indicate the service capabilities of the slice services provided by the operator node to the notarized third party node.

A selection unit 1104 for selecting a test node from the nodes participating in blockchain consensus using a random selection algorithm before the receiving unit receives the test result.

In one embodiment, the selecting unit 1104 is further configured to verify whether the random numbers respectively published in the plurality of nodes match with the hash values previously respectively published, where the hash values are obtained by performing hash operations by using the random numbers of the nodes.

In one embodiment, the selection unit 1104 is further configured to determine a test node from the matched plurality of nodes using a mapping operation. Alternatively, the mapping operation may include a modulo operation, where the selecting unit 1104 may obtain a modulo operation value by performing a modulo operation on N by using a joint hash value obtained by performing a joint hash operation on random numbers of the matched nodes, and determine a test node from the matched nodes according to the modulo operation value. The random numbers and hash values, as well as the joint hash values and N, published by each of the plurality of nodes are recorded in a slice contract.

A notification unit 1105, configured to notify the test node to write test request information into the slice contract according to an external test interface and a resource validity test mode defined by the operator node for the slice service in the slice contract; the test request information comprises an address of the test node, and the test request information is used for indicating the operator node to provide slicing service for the test node.

Optionally, the slice service processing apparatus may further perform related operations in the method embodiments described above, which are not described in detail herein.

Referring to fig. 12, fig. 12 is a schematic structural diagram of another slice service processing apparatus according to an embodiment of the present application. The slice service processing apparatus may include: a receiving unit 1201, a responding unit 1202, a selecting unit 1203, and a determining unit 1204.

A receiving unit 1201, configured to receive a notification message from the blockchain, where the notification message is sent when the test passing information of the slice service is written into the blockchain, and is used to indicate that the operator node has activated the slice service; the slicing service is provided by an operator node selected by the tenant node;

In one embodiment, the receiving unit 1201 is further configured to receive a notification message from the tenant contract, where the notification message is specifically that the slice contract is activated to invoke the tenant contract to send when the test passing information of the slice service is written into the slice contract.

A response unit 1202, configured to use the slicing service provided by the operator node in response to the notification message.

In one embodiment, the response unit 1202 is further configured to use the slice service provided by the operator node according to the external use interface of the slice service in the slice contract in response to the notification message.

A selecting unit 1203 is configured to select, before the receiving unit receives the notification message from the blockchain, an operator node that provides the slicing service according to a directory contract, where the directory contract includes information for maintaining the slicing service provided by each operator node of the blockchain.

In one embodiment, the selecting unit 1203 is further configured to query whether a required slice service exists in a slice directory contract, where the slice directory contract includes information of each slice service that has been deployed by each operator node.

Optionally, the selection unit 1203 is further configured to select an operator node providing the slicing service, if any.

Optionally, if not, the selecting unit 1203 is further configured to query whether the operator node in the resource directory contract has a service capability for providing the slice service; the selecting unit 1203 is further configured to select an operator node having a service capability for providing the slicing service if the operator node in the resource directory contract has the service capability for providing the slicing service.

A determining unit 1204, configured to determine a tenant contract, where the tenant contract includes interface information of a tenant node, and information of a slicing service selected by the tenant node, an operator node, and a service fee paid by the tenant node for the slicing service.

Referring to fig. 13, fig. 13 is a schematic structural diagram of another slice service processing apparatus according to an embodiment of the present application. The slice service processing apparatus may include: a receiving unit 1301, a providing unit 1302, an updating unit 1303, a deploying unit 1304, a defining unit 1305.

A receiving unit 1301 for receiving a service fee from a blockchain; the service fee is sent when the test of the slice service is written into the blockchain through information, and is paid by the tenant node for the slice service provided by the operator node.

In one embodiment, receiving unit 1301 is further configured to receive payment credentials from a tenant contract; the payment certificate is transmitted by calling the tenant contract when the written test passing information in the slice contract is activated; the test passing information is used for indicating that the slicing service provided by the operator node is selected to pass by the tenant node; the payment credentials are used to instruct the tenant node to pay evidence to the operator node for a service fee pre-stored for the slicing service.

A providing unit 1302 is configured to activate a slicing service according to interface information of a tenant node in the blockchain and provide the slicing service to the tenant node. The system is used for providing slicing service for the tenant nodes according to tenant contracts, wherein the tenant contracts comprise interface information of the tenant nodes.

In one embodiment, the providing unit 1302 is further configured to provide a slicing service to the tenant node according to a tenant contract, where the tenant contract includes interface information of the tenant node.

In one embodiment, the providing unit 1302 is further configured to provide a slice service to the test node using the external test interface.

In one embodiment, the providing unit 1302 is further configured to provide a slice service to the notarized third party node using the external test interface.

An updating unit 1303, configured to update, before the receiving unit 1301 receives the service fee from the blockchain, an external test interface of the slice service to an address of a test node according to the test request information in the slice contract; the test request information includes the address of the test node.

In one embodiment, the updating unit 1303 is further configured to update, before the receiving unit 1301 receives the service fee from the blockchain, the external test interface of the slice service to the address of the notarized third party node according to the test request information in the slice contract; the test request information includes an address of the notarized third party node.

A deployment unit 1304, configured to deploy, according to a tenant contract, a slice service requested by a tenant node before the receiving unit 1301 receives a service fee from the blockchain, where the tenant contract further includes information of the slice service selected by the tenant node, an operator node, and a service fee paid by the tenant node for the slice service.

A defining unit 1305, configured to define a slicing service, an external interface of the slicing service, a resource validity testing mode of the slicing service, and a decision parameter passing the test in the slicing contract; the external interfaces of the slice service comprise an external use interface and an external test interface.

Referring to fig. 14, fig. 14 is a schematic structural diagram of a communication device according to an embodiment of the application. The communication device may include: a processor 1401, a communication interface 1402, and a memory 1403.

The processor 1401 can execute the above-described operations related to steps S401 to S403 shown in fig. 6a, steps S101 to S103 shown in fig. 6b, and also the operations related to steps S201, S202, S210 to S212 shown in fig. 7a, and steps S301, S302, S305, S306 to S308 shown in fig. 10a by executing the executable program code of the memory 1403; the communication interface 1402 can perform the above-described related operations of step S209 shown in fig. 7a by executing the executable program code of the memory 1403, which will not be described in detail herein.

In one embodiment, the processor 1401 may perform the related operations of step 407 shown in fig. 6a and step S107 shown in fig. 6b and may also perform the related operations of step S216 shown in fig. 7a and step S312 shown in fig. 10a by executing the executable program code of the memory 1403; the communication interface 1402 executes the executable program code of the memory 1403 to perform the operations related to step S404 shown in fig. 6a and step S104 shown in fig. 6b, and to perform the operations related to step S213 shown in fig. 7a and step S309 shown in fig. 10a, which will not be described in detail.

In one embodiment, the processor 1401 may perform the related operations of step S406 shown in fig. 6a and step S106 shown in fig. 6b, and may also perform the related operations of steps S204, S205, S215 shown in fig. 7a and steps S303, S304, S311 shown in fig. 10a by executing the executable program code of the memory 1403; the communication interface 1402 executes the executable program code of the memory 1403 to perform the operations related to step S405 shown in fig. 6a and step S105 shown in fig. 6b, and also to perform the operations related to step S214 shown in fig. 7a and step S310 shown in fig. 10a, which will not be described in detail herein.

The present application also provides a computer readable storage medium having stored therein a computer program which, when executed by a processor, performs the functions of any of the method embodiments described above.

In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer instructions are loaded and executed on a computer, the processes or functions described in accordance with embodiments of the present application are produced in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by a wired (e.g., coaxial cable, fiber optic, digital subscriber line (digital subscriber line, DSL)) or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., a floppy disk, a hard disk, a magnetic tape), an optical medium (e.g., a high-density digital video disc (digital video disc, DVD)), or a semiconductor medium (e.g., a Solid State Disk (SSD)), or the like.

The foregoing is merely illustrative of the present application, and the present application is not limited thereto, and any person skilled in the art will readily recognize that variations or substitutions are within the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A slice service processing method, the method comprising:

verifying whether a slice service has a service capability of the slice service purportedly provided by an operator node;

writing test passing information of the slice service into a blockchain when the slice service has a service capability of the slice service purportedly provided by the operator node; the test pass information of the slice service is used to activate the slice service to a tenant node and pay a service fee to the operator node, the service fee being paid by the tenant node for the operator node to provide the slice service.

2. The method of claim 1, wherein the verifying whether the slicing service has the service capability of the slicing service purportedly provided by an operator node comprises:

Determining whether the slice service passes or not according to a test result and a decision parameter of the slice service passing test in the slice contract, wherein the test result is used for indicating the service capability of the slice service provided by an operator node;

the information stored by the slicing contract comprises decision parameters for slicing services provided by the operator node and passing slicing service tests.

3. The method of claim 2, wherein writing test pass information for the slice service into a blockchain comprises:

writing test passing information of the slicing service into the slicing contract;

the test passing information is specifically used for activating the slicing contract to call a tenant contract to send a payment certificate to the operator node and sending a notification message to the tenant node;

the payment credential is evidence that the slice contract invokes the tenant contract, paying the service fee to the operator node; the notification message is used for notifying the tenant node that the operator node has activated the slicing service;

the information published by the tenant contract comprises information of slicing services selected by the tenant node and operator nodes, and service fees paid by the tenant node for the slicing services are stored.

4. The method according to claim 2, wherein the method further comprises:

and receiving the test result, wherein the test result is obtained by monitoring the slicing service provided by the operator node to the test node by the monitoring node.

5. The method of claim 4, wherein prior to receiving the test result, the method further comprises:

selecting the test node from nodes participating in the blockchain consensus by using a random selection algorithm;

according to an external test interface and a resource effectiveness test mode defined by the operator node for the slicing service in the slicing contract, notifying the test node to write test request information into the slicing contract;

the test request information comprises an address of the test node, and the test request information is used for indicating the operator node to provide the slicing service for the test node.

6. The method of claim 5, wherein selecting the test node from the nodes participating in blockchain consensus using a random selection algorithm comprises:

verifying whether the random numbers respectively published in the plurality of nodes are matched with the hash values respectively published in advance, wherein the hash values are obtained by carrying out hash operation on the random numbers of the nodes;

The test node is determined from the matched plurality of nodes using a mapping operation.

7. The method of claim 6, wherein the random numbers and hash values published by each of the plurality of nodes are recorded in the slice contract.

8. The method according to claim 2, wherein the method further comprises:

writing test request information into the slice contract, wherein the test request information comprises an address of a notarized third party node;

obtaining a test result using the slice service provided from the operator node;

the test result is used for indicating the service capability of the slice service provided by the operator node to the notarized third party node.

9. The method of any of claims 2 to 8, wherein the slice contract is further used to invoke a directory contract to update the slice service into a rented slice service in the directory contract;

the directory contract is used for publishing information of slicing services provided by each operator node.

10. A slice service processing method, the method comprising:

receiving a notification message from a blockchain, the notification message being sent when test passing information of a slice service is written into the blockchain and being used for indicating an operator node to activate the slice service; the slicing service is provided by the operator node selected by the tenant node; the test passing information is a verification node for activating the slice service to the tenant node and paying a service fee to the operator node when the slice service is verified to have the service capability of the slice service purported to be provided by the operator node; the service fee is paid by the tenant node for the operator node to provide the slicing service;

And responding to the notification message, and using the slicing service provided by the operator node.

11. The method of claim 10, wherein the receiving a notification message from a blockchain comprises:

receiving the notification message from the tenant contract, wherein the notification message is specifically that when the test passing information of the slicing service is written into the slicing contract, the slicing contract is activated to call the tenant contract to send;

the information stored in the slice contract comprises information whether the slice service passes the test or not;

the information published by the tenant contract comprises information of slicing service selected by the tenant node and operator nodes.

12. The method of claim 11, wherein said responding to said notification message to use said slicing service provided by said operator node comprises:

and responding to the notification message, and using the slicing service provided by the operator node according to an external use interface of the slicing service in the slicing contract.

13. The method of claim 10, wherein prior to receiving the notification message from the blockchain, the method further comprises:

Selecting an operator node providing slicing service according to a directory contract, wherein the directory contract comprises information for maintaining slicing service provided by each operator node of the blockchain;

determining a tenant contract, wherein the tenant contract comprises interface information of the tenant node, information of the slicing service selected by the tenant node, the operator node and service fees paid by the tenant node for the slicing service.

14. The method of claim 13, wherein selecting an operator node to provide slicing services according to a directory contract comprises:

inquiring whether a required slice service exists in a slice directory contract, wherein the slice directory contract comprises information of all the slice services deployed by all the operator nodes;

if so, selecting an operator node for providing the slicing service;

if not, inquiring whether the operator node in the resource directory contract has the service capability for providing the slicing service;

and if the operator node in the resource directory contract has the service capability of providing the slicing service, selecting the operator node with the service capability of providing the slicing service.

15. A slice service processing method, the method comprising:

receiving a service fee from the blockchain; the service fee is sent when the test passing information of the slice service is written into the blockchain, and is paid by a tenant node for the slice service provided by an operator node; the test passing information is a verification node for activating the slice service to the tenant node and paying the service fee to the operator node when the validation node verifies that the slice service has the service capability of the slice service purported to be provided by the operator node;

and activating the slicing service and providing the slicing service for the tenant node according to the interface information of the tenant node in the blockchain.

16. The method of claim 15, wherein receiving a service fee from a blockchain comprises:

receiving payment credentials from a tenant contract;

the payment certificate is transmitted by calling the tenant contract when being activated when the test passing information is written in the slice contract; the test passing information is used for indicating that the tenant node selects the slicing service provided by the operator node to pass the test; the payment certificate is used for indicating the evidence that the tenant node pays to the operator node for the service fee prestored by the slicing service;

the information published by the tenant contract includes storing service fees paid by the tenant node for slicing services.

17. The method of claim 15, wherein the providing the slicing service to the tenant node based on interface information of the tenant node in the blockchain comprises: and providing the slicing service to the tenant node according to a tenant contract, wherein the tenant contract comprises interface information of the tenant node.

18. The method of claim 15, wherein prior to receiving a service fee from a blockchain, the method further comprises:

updating an external test interface of the slicing service into an address of a test node according to test request information in a slicing contract; the test request information comprises the address of the test node;

providing the slicing service to the test node by utilizing the external test interface;

the information stored by the slice contract comprises an external test interface of the slice service.

19. The method of claim 15, wherein prior to receiving a service fee from a blockchain, the method further comprises:

Updating an external test interface of the slice service into an address of a notarized third party node according to test request information in a slice contract; the test request information comprises an address of a notarized third party node;

providing the slice service for the notarized third party node by utilizing the external test interface;

20. The method of any of claims 15 to 19, wherein prior to the receiving a service fee from a blockchain, the method further comprises:

deploying the slicing service requested by the tenant node according to a tenant contract, wherein the tenant contract further comprises information of the slicing service selected by the tenant node, service fees paid by the operator node and the tenant node for the slicing service;

defining the slicing service, an external interface of the slicing service, a resource validity test mode of the slicing service and a decision parameter passing the test in the slicing contract; the external interfaces of the slicing service comprise an external use interface and an external test interface.

21. A slice service processing apparatus, the apparatus comprising:

A determining unit for verifying whether a slice service has a service capability of the slice service purportedly provided by an operator node;

a writing unit configured to write test passing information of the slice service into a blockchain when the slice service has a service capability of the slice service purportedly provided by the operator node; the test pass information of the slice service is used to activate the slice service to a tenant node and pay a service fee to the operator node, the service fee being paid by the tenant node for the operator node to provide the slice service.

22. The apparatus of claim 21, wherein the apparatus further comprises:

and the receiving unit is used for receiving a test result, wherein the test result is obtained by monitoring the slicing service provided by the operator node to the test node by the monitoring node.

23. A slice service processing apparatus, the apparatus comprising:

a receiving unit, configured to receive a notification message from a blockchain, where the notification message is sent when test passing information of a slice service is written into the blockchain, and is used to indicate an operator node that the slice service has been activated; the slicing service is provided by the operator node selected by the tenant node; the test passing information is a verification node for activating the slice service to the tenant node and paying a service fee to the operator node when the slice service is verified to have the service capability of the slice service purported to be provided by the operator node; the service fee is paid by the tenant node for the operator node to provide the slicing service;

24. The apparatus of claim 23, wherein the apparatus further comprises:

a selecting unit, configured to select, before the receiving unit receives the notification message from the blockchain, an operator node that provides a slicing service according to a directory contract, where the directory contract includes information for maintaining the slicing service provided by each operator node of the blockchain;

a determining unit, configured to determine a tenant contract, where the tenant contract includes interface information of the tenant node, information of the slicing service selected by the tenant node, the operator node, and a service fee paid by the tenant node for the slicing service.

25. A slice service processing apparatus, the apparatus comprising:

a receiving unit for receiving a service fee from the blockchain; the service fee is sent when the test passing information of the slice service is written into the blockchain, and is paid by a tenant node for the slice service provided by an operator node; the test passing information is a verification node for activating the slice service to the tenant node and paying the service fee to the operator node when the validation node verifies that the slice service has the service capability of the slice service purported to be provided by the operator node;

26. A communication device, comprising: a processor;

the processor is used for verifying whether the slicing service has the service capability of the slicing service which is purported to be provided by an operator node;

the processor is further configured to write test passing information of the slice service into a blockchain when the slice service has a service capability of the slice service purported to be provided by the operator node; the test pass information of the slice service is used to activate the slice service to a tenant node and pay a service fee to the operator node, the service fee being paid by the tenant node for the operator node to provide the slice service.

27. The apparatus of claim 26, wherein the apparatus further comprises a communication interface;

the communication interface is configured to receive a test result, where the test result is a test result that the monitoring node monitors the slicing service provided by the operator node to the test node.

28. A communication device, comprising: a processor and a communication interface;

the communication interface is used for receiving a notification message from a blockchain, wherein the notification message is sent when test passing information of a slice service is written into the blockchain and is used for indicating an operator node to activate the slice service; the slicing service is provided by the operator node selected by the tenant node; the test passing information is a verification node for activating the slice service to the tenant node and paying a service fee to the operator node when the slice service is verified to have the service capability of the slice service purported to be provided by the operator node; the service fee is paid by the tenant node for the operator node to provide the slicing service;

the processor is configured to use the slicing service provided by the operator node in response to the notification message.

29. A communication device, comprising: a processor and a communication interface;

the communication interface is used for receiving service fees from the blockchain; the service fee is sent when the test passing information of the slice service is written into the blockchain, and is paid by a tenant node for the slice service provided by an operator node; the test passing information is a verification node for activating the slice service to the tenant node and paying the service fee to the operator node when the validation node verifies that the slice service has the service capability of the slice service purported to be provided by the operator node;

The processor is configured to activate the slicing service and provide the slicing service to the tenant node according to interface information of the tenant node in the blockchain.

30. A computer readable storage medium storing a computer program which, when run on a computer, causes the computer to perform the method of any one of claims 1 to 9, or to perform the method of any one of claims 10 to 14, or to perform the method of any one of claims 15 to 20.