RU2741279C2 - Method of performing task in computer system - Google Patents

Abstract

FIELD: information technology.SUBSTANCE: present invention relates to organization of task execution by network computers. Such a result is achieved due to the fact that at least a part of a plurality of computers of the computer system form a distributed database; first computer creates a task, assigns a cost thereof, stores task data in a distributed database using a third computer, deposits cost of task execution in computer system using third computer and sends data on this task to second computer; second computer reports on readiness to take task to perform first computer; a first computer sends to a second computer a digital signature signed with a first data packet containing task data; second computer performs a task and provides a first computer with digitally signed digital packet data, containing a proof of task execution and a first data packet signed by a first computer; the first computer verifies the proof and sends to the second computer a third data packet signed with its digital signature, containing information on payment and proof of task execution; the second computer stores the third data packet in the computer system distributed database using the third computer, requests the deposited payment for the completed task at the computer system.EFFECT: technical result consists in ensuring reliability of task execution in distributed computer network with reduction of volume of stored data on task in this network.14 cl, 2 tbl, 9 dwg

Description

The technical field to which the invention relates

The invention relates to the field of data processing by computer systems, in particular to methods of organizing the execution of a task by computers on a network.

State of the art

There is a known solution (US 20090328036 A1, publ. 12/31/2009), in which the user can configure and purchase virtual computing resources in the same way as when buying and configuring physical computers. One embodiment allows the user to select various performance parameters that are widely known and used by the average personal computer user. For example, a base computer system can be selected and then tuned by choosing performance parameters such as processor brand, processor clock speed, random access memory (RAM) capacity, hard disk capacity, and so on. The performance parameters can then be used to tune the virtual machine resources to provide a virtual machine that substantially matches the performance parameters. However, this solution does not describe mechanisms for ensuring the reliability of tasks execution by virtual machines.

There is a known solution (US 8850442 B2, publ. 09/30/2014), in which a request is received to provide a virtual machine based on configuration information. Potential resources for hosting a virtual machine can be identified and estimated. Estimated potential resources can be ranked and the optimal resource to host the requested virtual machine can be selected based on the rating. The requested virtual machine can be provisioned on the selected optimal resource. However, this solution does not describe mechanisms for ensuring the reliability of tasks execution by virtual machines.

It is known that the solution (RU 2647697, publ. 03/16/2018) has been chosen as a prototype, which discloses a method for distributing resources between agents in a heterogeneous episodic computer network, and the method contains stages at which interaction between computer installations is provided by means of machine-to-machine information exchange, creating on each said computing installation a secure data store; provide guaranteed storage of incoming messages in a secure data storage; provide guaranteed processing of the message body; agents representing computing installations are connected to a heterogeneous episodic computer network, and interaction between computing installations is provided; after they create a decentralized database storing information about the current state of resources, agents form and submit requests, in which they indicate which resource the agents are ready to offer and at what cost. The message routing table is stored in a decentralized database.

However, this solution does not describe the mechanisms for ensuring the reliability of the execution of tasks by computing devices.

Disclosure of invention

In one aspect of the invention, a method is disclosed for performing a task on a computer system, comprising the steps of:

at least part of the plurality of computers of the computer system form a distributed database storing information in the form of associated data blocks;

the first computer of the computer system creates the task, assigns the cost of its execution, stores the task data in the distributed database of the computer system using the third computer of the computer system, deposits the cost of performing the task in the computer system using the third computer of the computer system, and sends data about this task to the second computer;

the second computer of the computer system informs about the readiness to take a task to perform the first computer of the computer system;

the first computer sends to the second computer a digitally signed first data packet containing task data;

the second computer performs the task and provides the first computer with a digitally signed second data packet containing the proof of the task and the first data packet signed by the first computer;

the first computer verifies the proof and sends to the second computer a digitally signed third data packet containing payment information and proof of task completion;

the second computer stores the third data packet in the distributed database of the computer system by means of the third computer of the computer system, requests the deposited payment of the performed task from the computer system.

In additional aspects, it is disclosed that the computer system checks the third data packet for validity and provides a portion of the cost or the full cost of the task to the second computer; a computer system is a blockchain computer system; the computer system issues part of the cost or the full cost of completing the task to the second computer through a predetermined number of blockchain blocks; if the first computer finds an error in the execution of the task by the second computer, it sends a refutation of the task execution to the computer system; along with the rebuttal, the first computer sends a predetermined collateral; the second computer sends at least some of the information necessary to complete the task to the computer system, the computer system checks the third data packet to determine whether the task has been completed; the computer system, depending on the results of the check, either takes the deposit of the first computer, or fines the second computer; the computer system forms a rating for the computers in the system; the penalty for the second computer is to lower its rating; the first computer delegates the verification obligation to any other computer on the network; the first computer creates an entry in the distributed database, according to which it gives permission to use part of its funds to pay for tasks; the first computer sends the task data to the fourth computer of the computer system, which becomes a validation delegate; the second computer, before executing the task by means of the third computer, checks that the deposited cost of performing the task is sufficient to pay for the cost of performing the task.

In another aspect of the invention, a method for performing a task on a computer system is disclosed, comprising the steps of:

the first computer instructs the second computer to complete the task, while all data exchanged between the first and second computers from the start of the task to its completion is stored in the first sequence of blocks of the blockchain;

wherein the first computer stores the first block of the first blockchain blockchain, and the second computer stores the second block of the first blockchain blockchain in a second blockchain blockchain stored in the third computer.

In another aspect of the invention, a computer system for performing a task is disclosed, comprising:

- a set of computers of a computer network, configured to store network data in a sequence of blocks of a blockchain network;

- the first computer, configured to instruct the second computer to complete the task, save the data that it exchanges with the second computer from the start of the task to its completion, in a sequence of blockchain blocks created in conjunction with the second computer, save data about the assigned task in the sequence of blocks of the blockchain network ;

- a second computer configured to perform the task of the first computer, to store the data that it exchanges with the first computer from the start of the task to its completion in the first sequence of blocks of the blockchain; save data about the completed task in the block sequence of the blockchain network.

In another aspect of the invention, a method is disclosed for performing tasks on a computer system, comprising the steps of:

at least part of the plurality of computers of the computer system form a distributed database storing information in the form of associated data blocks;

the first computer of the computer system creates the task, assigns the cost of its execution, deposits the cost on the third computer of the computer system, stores the data about the task and sends data about this task to the performer;

the second computer of the computer system responds to the task;

the first computer creates the first data packet containing the task and the digital signature of the first computer and sends the data packet to the second computer;

the second computer requests all information necessary to complete the task from the first computer and upon receiving the requested information, provides the first computer with a second data packet containing a confirmation of the start of the task and a digital signature sent by the first computer;

the first computer verifies the proof and sends to the second computer a third data packet containing the proof of payment information and the digital signature of the first computer;

the second computer communicates with the third computer, which provides access to the distributed database, checks whether the payment information matches the cost of the task, and starts to perform the task;

when the second computer has completed the task, it requests payment from the third computer and records data about the completed task in a distributed database using the third computer.

The main tasks solved by the claimed invention are the distribution of the resources of the computer network between the computers of the network, ensuring the reliability of the tasks undertaken by the computers, ensuring the possibility of checking the fulfillment of tasks.

The essence of the invention lies in the fact that a distributed database is created in a computer network storing information in the form of linked data blocks, in which each data block contains information about the previous one. The database stores, among other things, information about a task that one of the many computers on the network has published for execution, and information about the execution of this task by another computer. Moreover, in a distributed database of a computer network, only the amount of information is stored that is necessary and sufficient to check the completion of the task, all other information is stored in the computer that published the task and the computer that reported that it completed the task. That is, although the computer that published the task and the computer performing the task exchange a large amount of information and many data packets, not all, but only the necessary and sufficient information, is stored in the distributed database of the computer network to ensure that the task is completed. This is ensured by the fact that the two computers themselves write the information that is exchanged in linked blocks.

The technical result achieved by the solution is to ensure the reliability of the task in a distributed computer network while reducing the amount of stored data about the task in this network.

Brief Description of Drawings

FIG. 1 shows a computer system.

FIG. 2 shows a block diagram for explaining the principle of the method.

FIG. 3a, 3b, 3c show the exchange process when solving the data storage problem.

FIG. 4a, 4b, 4c show the exchange process when solving the data storage problem.

FIG. 5a shows the exchange process when solving the data storage problem.

Implementation of the invention

In today's world, most computing devices are networked. A particular type of such networks is a computer network. A computer network (Fig. 1) is a set of computers connected by communication lines and running under the control of special software. Communication lines can be both wired and wireless. The networks themselves can be both centralized and decentralized, and can also have signs of both centralization and decentralization.

Storage and transmission of information is the main purpose of any computer networks. Large amounts of information are stored in databases to provide easy search and access to such data. In the modern world, together with centralized databases that are stored on one computing device, cloud databases and distributed databases are actively used.

Distributed database - a database, the components of which are located in various nodes of a computer network in accordance with some criterion.

Distributed databases can have different levels of replication - from the complete absence of duplication of information, to complete duplication of all information in all distributed copies (for example, blockchain).

Distribution (including fragmentation and replication) of the database across multiple sites is not visible to users. This property is called transparency, and the technology for distributing and replicating data across multiple computers connected by a network is fundamental to realizing the concept of data independence from the storage environment.

Separately, it is necessary to clarify about the blockchain technology. Blockchain is a continuous sequential chain of blocks (linked list), built according to certain rules, containing information. Most often, copies of blockchains are stored on many different computers independently of each other.

The development of blockchain technology has made it possible for smart contracts to emerge. Smart contract is a computer algorithm designed to conclude and maintain contractual relationships in blockchain technology.

The parties sign a smart contract using methods similar to signing the sending of funds in existing cryptocurrency networks. After signing by the parties, the smart contract comes into force. To ensure the automated execution of the obligations of a smart contract, an existence environment is inevitably required that allows you to fully automate the execution of contract clauses. This means that smart contracts can only exist within an environment that has unhindered access of executable code to smart contract objects. All conditions of a smart contract must have a mathematical description and clear logic of execution. In this regard, the first smart contracts have the task of formalizing the simplest relationships, consisting of a small number of conditions. Having unhindered access to the objects of the smart contract, the smart contract monitors, according to the specified conditions, the achievement or violation of the clauses of the smart contract and makes independent decisions based on the programmed conditions. Thus, the main principle of a smart contract is complete automation and reliability of the execution of contractual relations.

At the moment, the Internet of Things is not yet so well developed, therefore, one of the few environments in which a smart contract can be fully implemented is the computer environment.

The computing environment has two main functions: data storage and computation (data processing). And network computers can share these capabilities with each other on the basis of contractual relations (using a smart contract).

Currently, most computers or other computing facilities on the network have unused reserves of both memory and computing power. At the same time, some users lack the storage capacity to store their information, while others are ready to provide their unused data storage facilities. The situation is similar with computing resources.

The main question that appears in any decentralized system is who or what ensures the reliability of the contractual relationship.

If one computer rents its hard disk space from another computer, then there must be a guarantee that the data will be stored for a specified time, that payment will be made according to the contract, that there will be no distribution of confidential or personal information, etc.

These problems are largely solved through the use of smart contracts, in which all the terms of the contract are programmed.

Absolutely the same applies to the lease of computing power of network computers. There must be a guarantee that a computer that claims to provide a specific amount of computing power will provide it for all the paid time.

With all the obvious advantages of using smart contracts (information security, decentralization, lack of regulators, clear operating rules, automatic execution of conditions), the difficulty arises in that the number of transactions per unit of time in the blockchain network is fundamentally limited and rather low. In addition, due to the nature of the blockchain, the frequent exchange of information between participants in the blockchain transactions leads to a significant increase in the requirements for the volume of data storage for these transactions.

The developers proposed a solution that can preserve all the advantages of using smart contracts and eliminate the above main disadvantages.

In the proposed solution, as shown in FIG. 2, two computers on the network conclude a deal to provide resources and create their own local blockchain between themselves, containing information on all aspects of the conclusion, execution and completion of the transaction.

In this case, part of the information necessary and sufficient to resolve possible conflicts is transferred to the global blockchain, formed by all or at least some computers on the network.

Thus, a distributed database is stored in a computer network, which stores information about all concluded transactions in the form of linked data blocks (blockchain). This distributed database is formed by a plurality of computers on the network according to conventional blockchain technology principles known in the art. This network forms a computer system with distributed storage and computing resources.

Brief description of the proposed method

One of the computers in the system (let's call it the "first computer", although the serial numbers have no meaning, but serve only to identify computers within the framework of the explanation of the developed method) there is a need for additional space to store a file or additional computing power, it creates a task for storing data or providing computing power and sends this task to the system. The task must be described in an exhaustive way, so that another computer in the system, based on its resources, can unambiguously decide whether it can take on it and perform it.

When another computer in the system (let's call it the "second computer") decides that it can complete this task, it sends a corresponding message to the first computer.

The first computer creates the first data packet containing the task and the digital signature of the first computer and sends the data packet to the second computer. Also, the first computer deposits the cost of the task in the computer system, for example, on a third computer of the computer system.

The second computer requests all the information necessary to complete the task from the first computer and upon receiving the requested information provides the first computer with a second data packet containing confirmation of the start of the task and a digital signature sent by the first computer.

The confirmation is, in particular, his own electronic digital signature.

The first computer verifies the proof and sends to the second computer a third data packet containing the proof of payment information (digitally signed relevant information) and the digital signature of the first computer. For each type of problem, a different method of proof is developed. For example, for storing data, the evidence will be both the file itself and sha56 (sha256 (file) + random string), any device on the network that stores the same file can verify the confirmation.

When a node (computer) saves a file, it encrypts it with its public key.

// Node

// encrypt - encryption by key or password, where publicKey is the public key

newfile = encrypt (file, publicKey)

proofMiner = sha256 (file)

Since the author of the task for storage also has this file (At the moment of loading), he knows the publicKey of the executor to whom he sent the task. The task author does the same function

proofTrue = sha256 (encrypt (file, Performer's Public Key))

Next, the executive node sends the proofMiner to the author, and the author is already comparing.

if proofTrue = = proofMiner:

sendSignWithPay

else:

wrongProof

Further, we can give proof to the network, either of the violation or of the payment.

The first computer with a computer system has a contract on which denet tokens are located, which are used to pay for services within a computer network and are the equivalent of real money. You cannot withdraw funds from the contract, but you can provide others with digital signatures about payment, and if someone wants to withdraw funds, then a delay of N blocks automatically appears (the number of blocks is selected in advance) in the contract. During this time, any participant can open a dispute regarding the transaction.

The second computer communicates with the computer system, in particular, with the third computer, checks that the payment information matches the cost of the task, and begins to complete the task.

When the second computer has completed the task, it requests payment from the computer system, in particular, the third computer, and records data about the completed task in a distributed database of the computer system, for example, using the third computer.

In additional aspects, the computer system checks the data on the completed task of the second computer for validity and gives part of the cost or the full cost of the task to the second computer according to the terms of the concluded transaction.

In some aspects, the computer system may be a blockchain computer system known in the art.

In some aspects, the computer system provides the cost or total cost of completing the task to the second computer through a predetermined number of blockchain blocks to enable disputes over the task between the first and second computers to be resolved. After the second computer has completed the task and reported it to the computer network, the first computer has information about it, and he has the opportunity to check and, if necessary, refute the fact of the task.

In some aspects, if the first computer finds an error in the execution of the task by the second computer, it sends a rebuttal of the task execution to the computer system, while along with the rebuttal, the first computer sends a predetermined collateral, which serves as a guarantee that there are no unreasonable rebuttals, since the collateral can be withheld by the system if the refutation is wrong.

The second computer then sends at least some of the information necessary to complete the task to the computer system, and the computer system checks the data from the second computer to ensure that the second computer is performing the task.

Alternatively, the second computer can send the root of the storage task dead tree to the computer system.

Further, the computer system, depending on the results of the check, either takes the pledge of the first computer if the check showed that the task was completed, or penalizes the second computer if the check showed that the task was not completed.

In one embodiment, the computer system generates a rating for the computers in the system so that users can select computers to perform their tasks based on a rating that reflects at least the success and the number of previously completed tasks.

If one of the computers did not complete the task that it took upon itself, then it is fined, in particular, its rating is lowered. Another penalty option is to reduce the cost of completing the task.

In one embodiment, the first computer delegates verification obligations to any other computer on the network. This is used in the case when a cluster of computers is connected and in one cluster there is a master node that distributes tasks over the local network.

In one embodiment, the first computer digitally signs the data packet in which it delegates the amount. Delegation refers to the transfer of the right to another computer to perform checks in its place. For example, a user who uploads data to the network is not always online, so he can give any node the role of "checking" for his tasks without transferring his private key.

In one embodiment, the first computer creates an entry in the distributed database that it authorizes to use a portion of its funds to pay for tasks. This option is implemented in the same way and for similar purposes as the option with the delegation of the amount.

In one embodiment, to improve reliability, the first computer sends task data to a fourth computer in the computer system, which becomes a validation delegate.

In one embodiment, the digital signature can be used to identify the author of the task, as well as verify the information contained in the task.

DESCRIPTION OF IMPLEMENTATION OPTIONS

Option 1. Data storage

The first computer created a task, we take sha3 (task) = = taskHash from it, then when the computers of the system create operations with this task, they sign taskHash in all messages and save sha3 (task) to themselves. At the time of saving the file, a local blockchain is formed between the first computer and the second computer - sha3 (taskHash + query + digSig) = = lastQuery, suppose that one of the parties to the agreement wants not to pay or simply stops working, then both will have a chain of operations digitally signed, the only moment of loss comes down to the very last block and the smallest operation.

To optimize this process, it is recommended to dump chains to a size of no more than 256 bytes, since if one of the parties is deceived, this chain will have to be transferred to the blockchain of the computer network as evidence. In the chain itself, it will be enough to provide the last state without passing the initial parameters of the task (for payment, getting a rating and resolving the conflict).

The general principle is that the computers of the system can negotiate between each other directly, and broadcast the very last stage of work to the blockchain.

Concrete private example of data storage implementation

Alice is a girl who has an archive of photos of herself and her friends from a secret event, Alice wants to save the archive on the computer system where her computer is located (the first computer). Alice is ready to pay 100 conventional monetary units - DNET. Bob is the owner of a computer (second computer) that has 30 GB free for rent, Bob wants to rent his 30 GB. This situation is illustrated in FIG. 3a.

Alice - creates a smart contract (Task SC) to complete the task and puts in it the amount for the task. In this case, Alice creates a task for storage, she already knows that Bob will perform this task, Alice signs the task with a digital signature (digSig Alice) for Bob and sends information about the task to Bob. As illustrated in FIG. 3b.

Bob asks for files (of the task itself for storage), if he agrees to complete the task by downloading them, he verifies these files and provides proof and his digital signature (digSig) to start execution. As illustrated in FIG. 3c. The creator of the smart contract can generate the task identifier TaskID, which is then used in the exchange of data to identify the task.

Alice verifies the proof and sends Bob, an off-chain transaction containing information that she agrees with Bob (proof Bob) and information that she pays the first payment for storing data (pay). Moreover, this transaction is also signed by her digital signature (digSig Alice). Which is illustrated in Fig. 4a. Moreover, the final transaction is sent to the blockchain of the computer system only after the task is completed or someone wants to withdraw funds.

Bob, in turn, verifies this information with the information specified in the task (that is, how much Alice should pay for the storage period N).

From this moment, Bob's rating begins to form.

When Bob finds sha3 (filekey + hashBlock) <difficult (Alice TaskSC), Bob requests a withdrawal of funds for completing the task to his balance in the smart contract. This is illustrated in Fig. 4b. As soon as the node receives the file, it saves it, encrypts it with its public key, then takes the hash from it, thus getting filekey (filekey = sha256 (encrypt (newFile, publicKey))). Difficulty is a measure of how difficult it is to find a hash that will be the next proposed goal of the network. The complexity in this solution is defined in the same way as in the Bitcoin network.

The smart contract checks the data for validity and makes it possible to withdraw the required amount through 50 blocks of the blockchain network. As illustrated in FIG. 4c, 5a.

This is enough time for Alice or another network participant performing the same task to post a refutation. After 50 blocks, Bob takes his earned money.

If Alice (or another network member who performed the same task) finds an error in Bob's calculations. Alice sends a pledge of 250 DNET tokens and waits for 50 blocks for Bob to prove that he is right (or not).

Bob proves ownership of the file by sending 1-4 MB of a piece of the file and the root of the tree faded from this task, the smart contract performs the operation of encrypting the file and checking the proof from Bob, if the proof is correct, Alice loses all balances partly in favor of the network, partly in favor Bob.

If Bob cannot prove otherwise, or Bob's proof was incorrect, then Bob will be punished with the sanctions prescribed in the smart contract. Full meta-information about the task itself enters the blockchain only at the moment when a dispute arises.

Option 2. Decentralized hosting

Decentralized hosting is a computer system that provides the ability for computers to share their resources with each other on a contractual basis.

Decentralized hosting combines 2 areas: a decentralized system in which devices share computing or memory resources (DeNet.Core) and a system that runs on top of DeNet.Core and generates tasks for DeNet.Core (DeNet.Hosting).

Further, a device is called a computing device that connects to the DeNet.Core network and shares its powers by performing tasks.

A rating is introduced in the computer system to protect users from unscrupulous landlords (devices that provide their resources). Each device on the network has its own rating.

The new device is rated zero and can only complete free tasks. You can get a rating by successfully completing the received tasks. The higher the rating of a device, the more likely it will be able to accept a payment task. The owner of the device indicates for how many DeNet tokens (conventional or real money units) he is ready to donate 100% of the specified resources. You can specify any amount.

As mentioned above, the rating is awarded after the successful completion of the task. The rating is calculated by the formula

ΔR = uptime⋅ (V _RAM ⋅G _RAM + V _CPU ⋅G _CPU +… + V _Net ⋅G _Net )

ΔR - rating that is awarded for completing the task

uptime - time spent on task execution

V _param - the volume of the lease _t parameter

G _param - function for finding the average cost of the rogat parameter for the last N paid problems:

N is the smallest number that meets the conditions:

where N _const and T _const are fixed values;

t _i is the time spent by the device on task i;

c _i - price per unit of the parameter param of the device when performing the considered task i.

Such determination of the rating ensures reliable determination of reliable devices for renting resources from them and, accordingly, ensures the reliability of the proposed task.

The list of parameters required for the correct distribution of tasks and the formation of a rating is given in the table below:

The device can freeze a certain amount of money, which guarantees its reliability. If the task is unsuccessful (for example, when the Internet or power is turned off), a part of the frozen funds is debited to the tenant. This guarantee increases the chance of getting tasks when there are other devices claiming these tasks.

A task is a collection of files and system requirements. For example:

work / main.py,

manifest.json

work / main.py - main application

manifest.json - application requirements

In this case, the task is a parser application with requirements for RAM, NET, CPU. After creating a task and searching for a device to start it, the application starts. If the device completed the task without errors, then it receives a rating equal to the average market value of the services it rendered. If the device performs the task with errors, then the device loses part of the rating and part of the frozen funds.

The customer forms the task by setting the necessary parameters of the computing system and the price for the work. This information is sent to the network device, which selects a landlord who is suitable for all the specified parameters and is ready to perform the work for the specified price.

An error during the task execution means that the landlord tried to trick the system. For example, setting deliberately false parameters or trying to read, replace data. Or, for some reason, additional restrictions have been created for the task running on the device, which violate the execution conditions. Disconnection of the Internet, electricity, wear of the hard disk, RAM, etc. - is also considered an error caused by the landlord.

If the device met the conditions of the allocated resources throughout the entire operation and there were no attempts to read or replace data on its part, then it is considered that the task was completed without errors. At the same time, if the execution of a task is interrupted due to internal errors, then for DeNet.Core it is not considered an error.

Suppose that the lessor managed to cheat the system: the device that is rented is not the device it claims to be, for example, instead of the declared 500 IOPS, the device actually has only 250. When the lessor starts a device with deliberately invalid parameters, then the device :

1. connects to the network;

2. receives a validating task;

3. receives a penalty (rating write-off and frozen funds).

In the event of an error due to the fault of the lessor, 9 * ΔR is deducted from his rating, which he could have earned, and the entire frozen amount is written off in favor of the computer network fund (DeNet.Rewards). Funds from the DeNet.Rewards fund are later distributed to bona fide landlords.

Checking the completion of a task is not checking the final answer. At this stage, you need to check that the device does not deceive us and executes the code that was sent. To do this, we have divided tasks into two types: static and dynamic.

Static tasks are tasks that can be fully verified by replication, that is, run again on any other device and compare the result.

Dynamic tasks are tasks that are difficult or impossible to verify by replication, that is, if they are run simultaneously on two different devices, the result of the task execution may be different. In addition, dynamic tasks have a property called state.

The state of an application is roughly the entire contents of its memory, these are all of its global variables, static variables, objects allocated on the stack, registers, open file descriptors and file offsets, open network sockets and their associated kernel buffers, etc. In fact, it is possible to save this state and resume the execution of this process elsewhere.

There is a stable state, that is, which never changes, for example, a web server that runs the "generate_random_number.php" script, which in turn outputs a random number.

There are states that are being generated, that is, a web server with the same "generate_random_number.php", which, after generating a number, creates a file with this number.

If we talk about a static task, that is (hosting files, adding two previously known numbers, etc.), then everything is simple: verification of execution occurs due to replication.

So, we have several ways to test a dynamic problem:

• Own library;

• Checksum check;

• Checking devices by tests;

• Closing the ability to access traffic through a network connection via an SSH tunnel;

• Test cases;

• Hash from the state (if it is a problem with a stable state).

Information about all tasks is recorded in the blockchain. Tasks that have not yet found the device where they will start are in the list of unaccepted tasks. After the executor is found, the task enters the blockchain, and the funds to pay for the task are frozen.

After completing the task, information about the completion (successful or unsuccessful) enters the transaction blockchain and the rating blockchain.

There is the following classification of tasks.

DeNet.Hosting is a hosting launched on the DeNet.Core network. Hosting is needed for the convenience of deploying web applications. Hosting generates and sends tasks to DeNet.Core according to the specified requirements.

There are several ways to upload your site to DeNet.

Method one

1. Create a file with requirements (manifest.json), which will take into account all hosting parameters, ram, ping, cpu, location, etc.

2. Create an archive with site files and manifest.json file.

3. Create a wallet with a DeNet token.

4. Create a task, add it to the list of unconfirmed transactions.

5. Wait until the task is accepted.

6. Top up your wallet balance and renew tasks on time.

Method two

1. Choose the architecture of your site (PHP + MySQL, CDN only, Django +…).

2. Choose the type of your site (WordPress, Joomla, self-written ...).

3. Select the type of site encryption.

4. Download all the necessary files (dumps, ssl-certificate, archive with the site).

5. Top up the balance with tokens.

6. DeNet.Hosting will handle the work with your site (load balancing, checking work, lease renewals, etc.).

Method three (expert)

Configuration in the case of uploading to one server

You can specify links to your libraries or trust the built-in libraries - in any case, at the time of publishing the tasks, the mining servers will see this configuration. Also, you prescribe the requirements for the miner, if you need a validation, use one of our libraries hosted on GitHub in the SecurityLibs section.

After you create all the necessary configurations and upload the requirements for the task, you will start receiving requests from the servers (miners). Once you choose the right one, your tokens and miner tokens will be frozen for the duration of the task.

Option 3. Computational tasks.

Computational tasks are any tasks that can be performed on computers.

Computational tasks combine 2 directions:

1. Static execution of tasks

2. Dynamic task execution

In the first case, one task is performed on one device, in the second case, one task is performed on more than one device, or more than one task is performed on more than one device.

Tasks, fulfillment requirements and rating are used in the same way as "Option 2. Decentralized hosting"

The embodiments are not limited to the embodiments described herein, a person skilled in the art based on the information set forth in the description and knowledge of the prior art will become apparent other embodiments of the invention without departing from the spirit and scope of the present invention.

Elements mentioned in the singular do not exclude the plurality of elements, unless otherwise specified.

The functional connection of elements should be understood as a connection that ensures the correct interaction of these elements with each other and the implementation of one or another functionality of the elements. Particular examples of functional communication can be communication with the ability to exchange information, communication with the ability to transmit electric current, communication with the ability to transmit mechanical motion, communication with the ability to transmit light, sound, electromagnetic or mechanical vibrations, etc. The specific type of functional relationship is determined by the nature of the interaction of these elements, and, unless otherwise indicated, is provided by widely known means using principles widely known in the art.

The methods disclosed herein comprise one or more steps or steps to achieve the described method. The steps and / or steps of the method can be substituted for each other without departing from the scope of the claims. In other words, if a specific order of steps or actions is not defined, the order and / or use of specific steps and / or actions may be changed without departing from the scope of the claims.

The application does not indicate specific software and hardware for the implementation of blocks in the drawings, but a person skilled in the art should understand that the essence of the invention is not limited to a specific software or hardware implementation, and therefore any software and hardware known in the art can be used to implement the invention. prior art. So hardware can be implemented in one or more specialized integrated circuits, digital signal processors, digital signal processing devices, programmable logic devices, user-programmable gate arrays, processors, controllers, microcontrollers, microprocessors, electronic devices, other electronic modules made with the ability perform the functions described in this document, a computer, or a combination of the above.

Although not specifically mentioned, it is obvious that when it comes to storing data, programs, etc., a computer-readable storage medium is meant, examples of computer-readable storage media include read only memory, random access memory, register, cache memory , semiconductor storage devices, magnetic media such as internal hard disks and removable disks, magneto-optical media and optical media such as CD-ROMs and digital versatile disks (DVDs), and any other storage media known in the art.

Although exemplary embodiments have been described in detail and shown in the accompanying drawings, it should be understood that such embodiments are illustrative only and are not intended to limit the broader invention, and that the invention should not be limited to the specific arrangements and structures shown and described. as various other modifications may be apparent to those skilled in the art.

The features mentioned in various dependent claims, as well as the implementations disclosed in various parts of the description, can be combined with the achievement of beneficial effects, even if the possibility of such a combination is not explicitly disclosed.

Claims (21)

1. A method for performing a task in a computer system, containing the stages at which: at least part of the plurality of computers of the computer system form a distributed database storing information in the form of associated data blocks; the first computer of the computer system creates the task, assigns the cost of its execution, stores the task data in the distributed database of the computer system using the third computer of the computer system, deposits the cost of performing the task in the computer system using the third computer of the computer system, and sends data about this task to the second computer; the second computer of the computer system informs about the readiness to take a task to perform the first computer of the computer system; the first computer sends to the second computer a digitally signed first data packet containing task data; the second computer performs the task and provides the first computer with a digitally signed second data packet containing the proof of the task and the first data packet signed by the first computer; the first computer verifies the proof and sends to the second computer a digitally signed third data packet containing payment information and proof of task completion; the second computer stores the third data packet in the distributed database of the computer system by means of the third computer of the computer system, requests the deposited payment of the performed task from the computer system. 2. The method according to claim 1, wherein the computer system checks the third data packet for validity and provides a portion of the cost or full cost of the task to the second computer. 3. The method of claim 2, wherein the computer system is a blockchain computer system. 4. The method of claim 3, wherein the computer system provides a portion of the cost or the full cost of completing the task to the second computer through a predetermined number of blockchain blocks. 5. The method of claim 4, wherein if the first computer finds an error in the execution of the task by the second computer, it sends a rejection of the task execution to the computer system. 6. The method of claim 5, wherein the first computer sends the predetermined collateral along with the rebuttal. 7. The method of claim 6, wherein the second computer sends at least some of the information needed to complete the task to the computer system, the computer system examines the third data packet to determine whether the task has been completed. 8. The method according to claim 7, in which the computer system, depending on the results of the check, either takes the pledge of the first computer, or penalizes the second computer. 9. The method of claim 2, wherein the computer system generates a rating for the computers in the system. 10. The method of claim 8, wherein the penalty for the second computer is to downgrade its rating. 11. The method of claim 2, wherein the first computer delegates verification obligations to any other computer on the network. 12. The method of claim 11, wherein the first computer creates an entry in the distributed database where it grants permission to use a portion of its funds to pay for tasks. 13. The method of claim 1, wherein the first computer sends task data to a fourth computer in the computer system that becomes a validation delegate. 14. The method of claim 1, wherein the second computer, prior to performing the task by the third computer, verifies that the deposited cost of performing the task is sufficient to pay for the cost of performing the task.

Images