# Patent

## Title
Distributed consumer cloud storage system

## Abstract

Example embodiments of the present invention relate to a method and apparatus for distributively storing a data object from a client node to a logical storage group in a network. The method includes selecting a plurality of storage nodes in the network. Portions of storage available at each selected storage node are then allocated as storage units. Further, the data object may be divided by the client node into a plurality of chunks. Each respective chunk is then encoded by the client node as a plurality of fragments. Storage units allocated at each selected storage node are then assigned to the logical storage group to store respective fragments of the data object.

## Background
A portion of the disclosure of this patent document may contain command formats and other computer language listings, all of which are subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
TECHNICAL FIELD
This application relates to distributively storing a data object to a logical storage group in a network.
BACKGROUND
Storage is a fundamental commodity of computation. Distributed storage mechanisms are becoming the de-facto method of data storage for the new generation of applications. The new generation of applications requires processing of terabytes and even petabytes of data. This is achieved by distributed processing. However, distributed storage systems suffer from low data transfer bandwidths and high access latencies. Various attributes, including cost, persistence, bandwidth, and latency, are traditional metrics for storage systems. However, the remarkable growth of communications and networking over has complicated what, traditionally, was a simple evaluation.
SUMMARY
Example embodiments of the present invention relate to a method and apparatus for distributively storing a data object from a client node to a logical storage group in a network. The method includes selecting a plurality of storage nodes in the network. Portions of storage available at each selected storage node are then allocated as storage units. Further, the data object may be divided by the client node into a plurality of chunks. Each respective chunk is then encoded by the client node as a plurality of fragments. Storage units allocated at each selected storage node are then assigned to the logical storage group to store respective fragments of the data object.
Example embodiments of the present invention also include a system and a computer program product for carrying out method steps. Other example embodiments relate to a method of storing data to a plurality of nodes.



BRIEF DESCRIPTION OF THE DRAWINGS
The above and further advantages of the present invention may be better under stood by referring to the following description taken into conjunction with the accompanying drawings in which:
FIG. 1 is a block diagram illustrating an example distributed network environment in which example embodiments of the present invention may be employed.
FIG. 2 is a block diagram illustrating an example embodiment of the present invention for providing a framework for intelligently creating logical storage in a distributed network environment.
FIG. 3 is a block diagram illustrating a plurality of storage nodes.
FIGS. 4A-4B are logical block diagrams illustrating an example method for distributively storing a data object.
FIGS. 5A-5B are block diagrams illustrating a logical storage group of N peer nodes in a ring topology managed by a management server and recovery in a single node-type failure.
FIGS. 6A-6B are block diagrams illustrating a logical storage group of N peer nodes in a ring topology managed by a management server and recovery in a neighboring nodes-type failure.
FIG. 7 is a diagram illustrating the geographic distribution of peer nodes.
FIG. 8 is a block diagram illustrating communications between peer nodes and management servers in two logical storage groups allowing a peer node to temporarily roaming from one logical storage group (i.e., domain) to another.
FIG. 9 is a block diagram illustrating the use of a passive token to decouple transactions between a client peer node and a target peer node and quota management operations with a management server.
FIGS. 10 and 11 illustrate an example embodiment management server and an example embodiment peer node, respectively.
FIG. 12 is a diagram illustrating an example embodiment method of the present invention embodied as program code or a program product.



DETAILED DESCRIPTION
FIG. 1 is a block diagram illustrating an example distributed network environment in which example embodiments of the present invention may be employed. The example environment includes a plurality of management servers 110-1-110-M (110, generally) and a plurality of peer nodes 120-1-120-N (120, generally) connected by a network 100. The peer nodes 120 may include consumer storage, such as personal computers and gaming consoles.
FIG. 2 is a block diagram illustrating an example embodiment of the present invention for providing a framework for intelligently creating logical storage in a distributed network environment. In a managed peer-to-peer storage network, effective integration of intelligence into the creation of storage groups, including space contributions from a plurality of nodes in the network, is extremely important. The framework includes a management server 210 that may be connected to and manage a plurality of peer nodes 220-1-220-N (220, generally) (e.g., peer nodes 110 of FIG. 1). Each respective peer node 220 may include storage devices 230-1-230-N (230, generally).
Each peer node 220 connects to the management server 210 in a star topology. In a preferred embodiment, the connection between each peer node 220 and the management server 210 is a persistent connection so that the management server 210 knows whether a particular peer node 220 goes offline. In other embodiments a heartbeat signal could be used to determine whether a peer node 220 goes offline.
As understood in the art, a source peer node 220 may establish a connection with the management server 210 to initiate a handshake with a target peer node 220 to establish a peer-to-peer connection for data transfer. The management server 210 then continues to manage the connections between the peer nodes 230. In a preferred embodiment, each peer node 220 may be located behind a network address translation (NAT) device. Accordingly, in such situations, the management server 210 facilitates peer-to-peer communications through the NAT devices (i.e., hold punching) to enable a handshake between peer nodes.
Creating a Logical Storage Group
FIG. 3 is a block diagram illustrating a plurality of storage devices 330-1-330-N (330, generally) (e.g., storage device 230 at peer node 220 of FIG. 2). Portions of available storage at the storage devices 330 may be allocated as a plurality of respective units 331-1-331-N, 332-1-332-N, 333-1-333-N (331-1-333-N, generally). Units 331-1-333-N allocated at each respective storage device 330 may be assigned together to form a logical storage group (denoted using respective shading in FIG. 3).
Referring to FIGS. 2 and 3 together, in order to determine what peer nodes should be selected for forming a logical storage group, a management server (e.g., management server 210 of FIG. 2) may monitor various metrics of the peer nodes 220. For example, the management server 210 may monitor, at each respective peer node 220, various criteria, including:
Node storage consumption—The selection process will prefer nodes with low usages (i.e., greater amounts of available storage). This helps distribute data and bandwidth workload evenly across the network;
Node storage consumption rate—The selection process not only monitors the storage usage but also the growth rate of the storage usage to distribute data and bandwidth workload evenly across the network;
Node stability tiers—The management server categorizes nodes in several tiers based on their stability (i.e., churn time, churn frequency and average online time). This allows the selection process create groups based on several strategies including grouping all highly stable nodes and grouping nodes with mixed stability. This provides improved storage efficiency;
Node locality—The selection process will meet objectives for both performance and reliability. Performance of a data object is improved if fragments are located close to the consumer. Reliability of a data object is improved if the system disperses the fragments as wide as possible;
Node security/trust level—This allows the system to create groups with only nodes that have an established trust level, as determined, for example, by a token;
Node usage pattern—This allows the system to match data consumption pattern with a particular node's usage pattern. This will improves network efficiency and node response time;
Node software version—This allows the system to form logical storage groups that offer features that are only available from certain nodes. Further, it allows the system of select nodes having varying software version so that, for example, if a particular software version is faulty, the data object may be recovered from the remaining nodes; and
Node hardware capability—This allows the system to form groups that offer features that depends on the node's hardware configuration.
The management server 210 then may assign storage units 331-1-333-N at the peer nodes 220 to logical storage groups according to the various metrics. For example, the management server 210 may prefer peer nodes 220 with low storage consumption over peer nodes 220 with high storage consumption, thereby distributing storage across the peer nodes 220 to reduce the chances of a particular peer node 220 being overly burdened. Likewise, the management server 210 may prefer peer nodes 220 with low storage consumption rates over peer nodes 220 with high storage consumption rates. Moreover, the management server 210 may match peer node consumption rates with peer node usage patterns to improve network efficiency and response time.
Further, the management server 210 may prefer peer nodes 220 with a favorable security metric. In this manner, the management server 210 may be able to guarantee to a user that a logical group assigned to peer nodes 220 with the favorable security metric will maintain a certain level of security while storing the fragments comprising the user's data objects, as will be described below. Similarly, the management server 210 may group peer nodes 220 in one of a plurality of tiers based on peer node stability to provide various levels of service to users according to a service level agreement.
Logical storage groups 331, 332, 333 may be created as need arises and from new peer nodes 220 as they become available in the network. Further, the load carried by a particular peer node 220 may be rebalanced at the cost of bandwidth and processing resources. In a preferred embodiment, peer nodes 220 having unfavorable metrics are avoided to avert the network transfers and calculations necessary for recovery should a node fail, become unavailable, or perform poorly for any other reason.
Distributively Storing a Data Object
FIGS. 4A-4B are logical block diagrams illustrating an example method for distributively storing a data object 400. A data object 400 may be divided by a client peer node (e.g., peer node 220 of FIG. 2 distributively storing a data object to the plurality of peer nodes) into a plurality of chunks 4101-410M (410, generally). Each respective chunk 410 then may be assigned by a management server to a logical storage group 431, 432, 433 and encoded as a plurality of fragments 410-1-410-N by the client node. The fragments 410-1-410-N then may be stored by the client node to respective units 431-1-431-N, 432-1-432-N, 433-1-433-N of the storage nodes 430-1-430-N at their respective peer nodes 420-1-420-N.
For example, as illustrated in FIG. 4A, a data object 400 may be divided into a plurality of chunks 4101-410M. A first chunk 4101 may be encoded as a plurality of fragments 4101-1-4101-N. The plurality of fragments 4101-1-4101-N comprising the first chunk 4101 may then stored to a respective logical storage group 431. As described above, the logical storage group 431 may be created by a management server (e.g., management server 210 of FIG. 2) and comprises a plurality of storage units 431-1-431-N. The storage units 431-1-431-N are assigned to the logical storage group 431 from storage allocated at a plurality of storage devices 430-1-430-N at a plurality of respective peer nodes 420-1-420-N managed by the management server.
Likewise, as illustrated in FIG. 4B, a second chunk 4102 may be encoded as a plurality of fragments 4102-1-4102-N. The plurality of fragments 4102-1-4102-N comprising the second chunk 4102 then may be stored to a respective logical storage group 432. As illustrated, the logical storage group 432 comprises storage units 432-1-432-N assigned to the logical storage group 432 and allocated at a plurality of storage devices 430-1-430-N at a plurality of respective peer nodes 420-1-420-N.
Mapping Fragments to Time Offsets in a Media File
Traditionally, video files are stored according to a mapping of time offsets to file locations in a directory structure or according to a hierarchical structure including chapters, scenes and frames. The hierarchical and directory tree structures allow a service to narrow down from the whole video to individual scenes and frames.
Distributively storing fragments of a file, however, as described above with respect to FIGS. 4A-4B, provides a number of advantages over traditional storage methods. For example, meeting a user's expectation in serving a video request in a video on demand (VOD) system is critical. However, in traditional VOD systems, entire files must be transferred to the user and directory structures traversed for playback. Therefore, waiting for a sufficient amount of a video file to download or for that segment to be located to begin playback at a desired location in the video file (i.e., seek time) detracts from the user experience.
Example embodiments of the present invention, however, are able to improve video seek time by providing a mapping of video file time offsets to chunks distributively stored in the network. The offset information may be stored by the management server in a table, which may store the data in XML format and as part of the metadata of original video file. Additionally, less metadata is generated by the coarse mapping of video offset times to video file chunks than in traditional video file structures. In alternate embodiments, the mapping of video file time offsets may be to the fragments, with a calculation performed to determine from which chunk the fragment was derived. The
As described above with respect to FIGS. 4A-4B, the video file is divided into a plurality of chunks, with each respective chunk coded into a plurality of fragments that are distributively stored to the peer nodes. Using the mapping, the management server keeps records of the video file time offset to chunk mapping. Given an offset request (i.e., seek), the management server looks up the chunk in which the offset may be found. It should be noted that the seek granularity is determined by the chunk size. For example, for a received offset value, the management server would return a chunk according to the mapping in the table. The management server will then support the user downloading the video file with the returned chunk, with a high priority, so the user does not have to download the entire video file in order to begin playback at the desired offset.
Storing Fragment Pairs at Nodes
FIGS. 5A-5B are block diagrams illustrating a logical storage group of N peer nodes 520-1-520-N (520, generally) in a ring topology managed by a management server 510. It should be clear to one of ordinary skill in the art that the lines connecting the peer nodes 520 and the management server 510 do not necessarily represent physical connections between the peer nodes 520 or between the peer nodes 520 and the management server 510 but rather represent logical connections.
FIG. 5A is a block diagram illustrating an example method by which the fragments (e.g., fragments 410 of FIGS. 4A-4B) may be coded to the peer nodes 520. As illustrated in FIG. 5A, fragments 530-1a-530-Nb are stored as pairs in a duplication pattern in a ring topology. A data object (e.g., a chunk 410 of FIG. 4) may be encoded into N=K+M pieces, such that any K fragments together can be used to reconstruct the original object.
For example, peer node 1 520-1 may store fragment 1 530-1b and fragment 2 530-2a, peer node 2 may store fragment 2 530-2b and fragment 3 530-3a, peer node 3 may store fragment 3 530-3b and fragment 4 530-4a, peer node 4 may store fragment 4 530-4b and fragment 5 530-5a, peer node 5 may store fragment 5 530-5b and fragment N 530-Na, and peer node N may store fragment N 530-Nb and fragment 1 530-1a. 
Recovery in a Single Node Failure
As illustrated in FIG. 5A, peer node 2 520-2 is detected by the management server 510 as unavailable in the network, as indicated by the hashed circle around peer node 2 520-2. For example, peer node 2 520-2 may be unavailable due to temporary node churn, which is extremely common. As will be described below with respect to FIG. 5B, the duplication pattern used to store the fragments in the ring topology allows the fragments stored at peer node 2 520-2, which is now unavailable, to be recovered from neighboring nodes (i.e., peer node 1 520-1 and peer node 3 520-3) storing the fragments (e.g., fragment 2 530-2a and fragment 3 530-3b. 
FIG. 5B is a block diagram illustrating an example method by which fragments may be recovered in a single node-type failure. As described above with respect to FIG. 5A, a peer node (e.g., peer node 2 520-2 of FIG. 5A) has become unavailable, for example, because of temporary node churn. As illustrated in FIG. 5B, the management server 510 may select a new peer node 520-N+1 as part of the logical storage group of N nodes. As described above with respect to FIG. 5A, the fragments previously stored by the unavailable peer node (e.g., fragment 2 530-2b and fragment 3 530-3a stored at peer node 520-2) are no longer available because of the unavailability of the peer node. However, because of the duplication pattern used to store the fragments, equivalent fragments (e.g., fragment 2 530-2a and fragment 3 530-3b) may be recovered from nodes neighboring the unavailable node (e.g., peer node 1 520-1 and peer node 3 520-3) and stored to the new peer node 520-N+1.
Accordingly, the management server 510 may establish peer-to-peer connections between the new peer node 520-N+1 and the respective neighboring peer nodes 520-1, 520-3. Once the peer-to-peer connections are established between the new peer node 520-N+1 and its neighboring peer nodes 520-1, 520-3, recovery may begin. For example, the new peer node 520-N+1 may request fragment 2 530-2a from peer node 1 520-1, which may then restore fragment 2 530-2a to the new peer node 520-N+1. Likewise, the new peer node 520-N+1 may request fragment 3 530-3b from peer node 3 520-3, which may then restore fragment 3 530-3b to the new peer node 520-N+1. Thus, a node may be recovered through only two network transactions.
This significantly reduces network traffic and processing overhead in comparison to traditional information dispersal methods. Traditionally, an object may be encoded to n=k+m fragments, when any k fragments out of the n fragments can be used to reconstruct the original object. To maintain the reliability level of the original object, the system has to repair the failed fragment. If node x fails, the system has to reconstruct the original object and regenerate fragment x stored at node x. This causes k−1 network transactions to retrieve the fragments necessary to reconstruct the original object and k−1 computations (i.e., decoding) to regenerate fragment x. For example, if a data object is divided into sixty fragments, thirty of which are required for recovery, a great amount of network and processing resources are needed to perform the recovery. However, in example embodiments of the present invention, only two network transactions are needed to recover the fragments stored at the unavailable node, with no computation required.
It should be noted that recovery of a node from neighboring nodes does not require that the underlying stored data object be a fragment stored in a unit. One of ordinary skill in the art will appreciate that any type of distributed storage may be used in which the portion of the data object stored at a failed node may be recovered from neighboring nodes.
Failure of one node (i.e., due to node churn) is statistically very likely. Less likely is the chance that multiple nodes fail, such as by node churn. However, this recovery method remains available for multiple-node failures as long as neighboring nodes do not fail.
Recovery in a Plurality Neighboring Node Failures
Even less likely is a scenario in which neighboring nodes fail. In such a situation, the recovery method described above with respect to FIGS. 5A-5B fails. However, traditional methods of recovery still may be used.
FIGS. 6A-6B are block diagrams illustrating a logical storage group of N peer nodes 620-1-620-N (620, generally) in a ring topology managed by a management server 610. It should be clear to one of ordinary skill in the art that the lines connecting the peer nodes 620 and the management server 610 do not necessarily represent physical connections between the peer nodes 620 or between the peer nodes 620 and the management server 610 but rather represent logical connections.
FIG. 6A is a block diagram illustrating an example method by which the fragments (e.g., fragments 410 of FIGS. 4A-4B) may be coded to the peer nodes 620. As illustrated in FIG. 6A, fragments are stored in a duplication pattern in a ring topology consistent with the storage method illustrated in FIG. 5A. However, as illustrated in FIG. 6A, neighboring peer node 2 620-2 and peer node 4 620-3 are detected by the management server 610 as unavailable in the network, as indicated by the hashed circles around peer node 2 620-2 and peer node 3 620-3. For example, peer node 2 620-2 and peer node 3 620-3 may be unavailable due to temporary node churn.
In contrast to FIG. 5B, the fragments stored at peer node 2 620-2 and peer node 3 620-3 cannot be recovered from their neighboring nodes (e.g., peer node 1 620-1 and peer node 4 620-4) because there is no node remaining in the logical storage group that stores fragment 3 630-3.
FIG. 6B is a block diagram illustrating an example method by which fragments may be recovered. As described above with respect to FIG. 6A, neighboring peer nodes (e.g., peer node 2 620-2 and peer node 3 620-3 of FIG. 6A) have become unavailable, for example, because of temporary node churn. As illustrated in FIG. 6B, the management server 610 may select new peer node 1 620-N+1 and new peer node 2 620-N+2 as part of the logical storage group of N nodes. As described above with respect to FIG. 6A, a fragment previously stored by the unavailable nodes (e.g., fragment 3 630-3a. 630-3b) is no longer available because of the unavailability of the neighboring peer nodes.
Accordingly, the management server 610 may select a peer node (e.g., peer node 1 620-1, peer node 4 620-4, peer node 5 620-5 or peer node n 620-N) to coordinate recovery of the unavailable fragment (e.g., fragment 3 630-3). For example, as illustrated in FIG. 6B, the management server 610 has selected peer node 4 620-4 as a coordinating peer node to recover fragment 3 630-3. The management server 610 may establish peer-to-peer connections between the other peer nodes 620-1, 620-5, 620-N and the coordinating peer node 4 620-4. Once the peer-to-peer connections are established between the coordinating peer node 4 620-4 and the other peer nodes 620-1, 620-5, 620-N, the coordinating peer node 620-4 may request fragments from the other peer nodes 620-1, 620-5, 620-N.
For example, as described above with respect to FIG. 5A, the fragments 630 may be coded to the peer nodes 620 in such a manner that only a fraction of the fragments are required to recreate the original data object. Thus, a reduced number of fragments (i.e., fewer than all N fragments) need to be gathered by the coordinating peer node 4 620-4 to recreate the original data object (e.g., data object 400 of FIG. 4) and calculate the unavailable fragments (e.g., fragment 2 630-2b, fragment 3 630-3a, 630-3b and fragment 4 630-4a).
For example, as illustrated in FIG. 6B, suppose the fragments 630 are coded to the peer nodes 620 in such a way that only four of the fragments 630 are needed to recreate the original data object. The coordinating peer node (e.g., peer node 4 620-4) only needs to gather four fragments to recreate the original data object and calculate the unavailable fragments. Thus, as illustrated in FIG. 6B, the coordinating peer node 620-4 may request fragment 1 630-1b from peer node 1 620-1, fragment 630-5b from peer node 5 620-5 and fragment N 630-Nb from peer node N 620-N. Note that the coordinating peer node, here peer node 4 620-4, already has at least one fragment (e.g., fragment 4 630-4b) available to it.
Once the coordinating peer node 4 620-4 has received the requisite number of fragments needed to recreate the original data object (as determined by the coding used in storing the fragments to the peer nodes), the coordinating peer node 4 620-4 may then recreate the original data object and divide the original data object into new fragments. Those new fragments then may be stored to the peer nodes 620. Thus, a plurality of neighboring peer nodes may be recovered through a reduced number of network transactions, as determined by the coding used in storing the fragments to the peer nodes, thereby significantly reducing network traffic and processing overhead resulting from traditional methods.
However, as illustrated above with respect to FIG. 5A, the chance of having to consume network and processing resources to perform such a recovery are reduced by storing fragment pairs at each node, thereby providing the ability to recover a node from neighboring nodes in a single node or, more specifically, a non-neighboring node failure scenario.
Geo-Distribution
A high degree of similarity of physical- and performance-based metrics among the fragments of a data object can reduce the reliability of the original data object. Therefore, when a logical storage group is formed, it is advantageous to ensure that the nodes storing the units of the logical storage group are geographically distributed. For example, if a disaster were to strike a particular geographic area in which a number of peer nodes are located, it is desirable to limit the number of fragments that may become unavailable because recovery of those nodes may be difficult or impossible.
To reduce such risk, for a data object divided into N fragments, the management server may divide the N fragments into multiple groups, with the fragments of each group being stored at peer nodes in a particular geographic area. Further, in a preferred embodiment, the size of the group may be as close to K as possible (where K is the number of fragments needed to restore the original data object).
As illustrated in FIG. 7, for example, presume a data object is encoded to eighteen fragments and six fragments are needed to reconstruct the data object. A logical storage group 700 for storing the eighteen fragments 730-1a-730-18b may include six peer nodes (PNs) in Hopkinton, Mass. (i.e., PN 1 720-1 through PN 6 720-6), six peer nodes in Chicago, Ill. (i.e., PN 7 720-7 through PN 12 720-12) and six peer nodes in Hollywood, Calif. (i.e., PN 13 720-13 through PN 18 720-18), all managed by a management server (MS) 710 in Hopkinton, Mass.
By geographically distributing the fragments, the chance of multiple fragments becoming unavailable is reduced. Further, the chance of neighboring nodes becoming unavailable is reduced. This provides a balance between increased performance provided by recovering a failed node from neighboring nodes (within the groups of six peer nodes) and increased reliability provided by the redundancy provided by the geographic distribution (i.e., only six fragments are required for reconstruction the data object).
Cross-Domain Node Roaming
In a large distributed peer-to-peer storage network, millions of nodes often will be partitioned into multiple logical storage groups based on various criteria, as described above, such as geographic location. A result of this partition schema is the limitation of load balancing that can be performed at the logical storage group level. For example, a peer storage node in one logical storage group may not be able to work with a peer storage node in another logical storage group because of a limited capability of establishing direct peer-to-peer communication channels between the two peer node belonging to different logical storage groups (i.e., domains). In other embodiments, a peer node may need to join a different logical storage group because of the failure of the management server coordinating its logical storage group.
Example embodiments of the present invention allow communications channels to be established in such a situation, thereby enabling load balancing across logical storage groups, by allowing a peer node in a first logical storage group to temporarily roam to a second logical storage group. When work loads across logical storage groups are not balanced, example embodiments of the present invention allow peer nodes from different logical storage groups to work together to balance the work load.
FIG. 8 is a block diagram illustrating communications between peer nodes 820 and management servers 810 in two logical storage groups allowing a peer node 820-2 to temporarily roam from one logical storage group (i.e., domain) to another. In order to achieve this, a peer node from a first logical storage group (i.e., a source peer node) (Peer Node (S)) 820-1 establishes a direct peer-to-peer communication channel to facilitate that work load balancing by sending a request 850 to a first management server (i.e., a source management server) (Management Server (S)) 810-1 in a first logical storage group to communicate with another peer node in a second logical storage group. The source management server 810-1 queries a second management server (i.e., a target management server) (Management Server (T)) 810-2 managing the second logical storage group to identify a peer node from the second logical storage group (i.e., a target node) (Peer Node (T)) 820-2. The target management server 810-1 then sends a request 860 to the target peer node 820-2 requesting the target peer node 820-2 to respond to the communication request from the source peer node 820-1 (850). The target peer node 820-2 then sends a request 865 to the source management server 810-1 to temporarily join the first logical storage group.
With the target peer node 820-2 now a temporary member of the first logical storage group (i.e., domain), direct communication handshaking to establish a peer-to-peer connection (870) between the source peer node 820-1 and the target peer node 820-2 may commence. Once this direct peer-to-peer connection is established across the two logical storage groups, the source peer node 820-1 may work with the target peer node 820-2 to balance the work load across the nodes (875). After load balancing is complete, the source peer node 820-1 and the target peer node 820-2 disconnect from each other. The target peer node 820-2 sends an indication 880 that it has left the first logical storage group and returns to its normal state in the second logical storage group.
I/O Quota Management
In a distributed system, managing quota effectively to avoid abuse (i.e., free-ride) is quite challenging. FIG. 9 is a block diagram illustrating the use of a passive token 950 to decouple transactions between a client peer node 920′ and a target peer node 920 and quota management operations with a management server 910. The approach discussed below addresses the free-ride problem in a distributed system through a passive method. In an example embodiment of the present invention, the management server 910 may issue an encrypted timed token 950 to a client peer node (i.e., a node writing to the peer nodes in a logical storage group) 920′. It should be noted that only the management server 910 can decrypt the token 950 and that the token will time out after a period of time that may be set as a parameter. Thus, the client peer node 920′ will authenticate periodically with the management server to acquire a valid token. Further, it should be understood that, although only one target peer node 920 is shown for purposes of this example embodiment, there may be a plurality of target peer nodes to which a respective plurality of fragments are written.
In a preferred embodiment, the token 950 includes an identifier that uniquely identifies a user of the client peer node 920′, an identifier that uniquely identifies the client peer node 920′, a timestamp and a storage quota associated with the user. When the client peer node 920′ user consumes a portion of its quota, the client peer node 920′ writes both the fragment 955 and the token 950 to the target peer nodes.
After the write is done, one of the target peer nodes (e.g., the target peer node 920) sends the following information to the management server 910: the token 950′, an identifier that uniquely identifies the source node that initiated the write transaction (i.e., source ID), the size of the write transaction, and an identifier associated with the write transaction (i.e., transaction ID). As understood in the art, the transaction ID may be used for rolling back transactions in certain circumstances. In certain embodiments, the target node can reduce the frequency of validation by sampling only small number of writes from a particular source node.
The management server then may confirm whether the token 950′ is valid. If the token 950′ is not valid because of mismatching source ID (i.e., the source ID in the encrypted token 950′ from the target node does not match the source ID in the initially issue token 950) or if the user is invalid, the client peer node 920′ identified by the target peer node 910 will be put on a black list. Further, the management server 910 will terminate the violating client peer 920′ node from performing transactions.
If the token 950′ is not valid because of a quota violation or a timeout, the management server 910 adds the user and the client peer node 920′ to a quota violation list. A warning may be issued to the user and the client peer node 920′. After a number of warnings exceeds a defined system limit, and if the quota violation continues, the client peer node 920′ will be terminated.
If the token 950′ is valid, the management server 910 will update the user's quota. Accordingly, a new token issued by the management server 910 will include the new quota.
By decoupling the transaction and quota management, the system is not overburdened with consistent token checks which would lead to I/O delays because of the extremely high scale of I/O transactions in large distributed systems. Otherwise, an inordinate amount of processing power would need to be allocated for security at the risk of performance. Accordingly, the method described above balances the needs of security and performance by not only decoupling processes devoted to I/O transaction and security, but also by reducing the number of times the token is checked (i.e., although the token is submitted with every write transaction, the token is not consistently checked with each write transaction). The target peer node 920 sends the token 950′ back to the management server periodically, which may be determined by a number of writes, the passage of time, or even randomly. Further, security is increased by having only one encryption/decryption point (i.e., only the management server, and not the target peer nodes 920, has access to the token content).
FIGS. 10 and 11 illustrate an example embodiment management server 1010 and an example embodiment peer node 1120, respectively. The management server 1010 includes a communications interface 1060, a processor 1040 and memory 1050 storing program logic 1055 for managing a data object from a client node distributively stored to a logical storage group in a network. Likewise, the peer node 1120 includes a communications interface 1160, storage 1130, a processor 1140 and memory 1150 storing program logic 1155 for distributively storing a data object at a plurality of storage nodes in a network managed by a central management server.
The methods and apparatus of this invention may take the form, at least partially, of program code (i.e., instructions) 1055, 1155 embodied in tangible non-transitory media, such as floppy diskettes, CD-ROMs, hard drives, random access or read only-memory, or any other machine-readable storage medium 1050, 1150. When the program code 1055, 1155 is loaded into and executed by a machine, such as the management server 1010 or the peer node 1120 of FIGS. 10 and 11, respectively, the machine 1010, 1120 becomes an apparatus for practicing the invention. When implemented on one or more general-purpose processors 1040, 1140, the program code 1055, 1155 combines with such a processor 1040, 1140 to provide a unique apparatus that operates analogously to specific logic circuits. As such a general purpose digital machine can be transformed into a special purpose digital machine.
FIG. 12 shows program logic 1255 embodied on a computer-readable medium 1230 as shown, and wherein the logic is encoded in computer-executable code configured for carrying out the distributive storage process of this invention and thereby forming a computer program product 1200.
The logic for carrying out the method may be embodied as part of the aforementioned system, which is useful for carrying out a method described with reference to embodiments shown in, for example, FIGS. 1-6. For purposes of illustrating the present invention, the invention is described as embodied in a specific configuration and using special logical arrangements, but one skilled in the art will appreciate that the device is not limited to the specific configuration but rather only by the claims included with this specification.
Although the foregoing invention has been described in some detail for purposes of clarity of understanding, it will be apparent that certain changes and modifications may be practiced within the scope of the appended claims. Accordingly, the present implementations are to be considered as illustrative and not restrictive, and the invention is not to be limited to the details given herein, but may be modified within the scope and equivalents of the appended claims.
In reading the above description, persons skilled in the art will realize that there are many apparent variations that can be applied to the methods and systems described. In the foregoing specification, the invention has been described with reference to specific exemplary embodiments thereof. It will, however, be evident that various modifications and changes may be made to the specific exemplary embodiments without departing from the broader spirit and scope of the invention as set forth in the appended claims. Accordingly, the specification and drawings are to be regarded in an illustrative rather than a restrictive sense.

## Claims

1. A method comprising:
selecting a plurality of storage nodes among a plurality of peer nodes, the plurality of selected storage nodes arranged in a star topology with and under control of a management server over respective management server-to-peer node management paths, the management server configured to establish and manage peer node-to-peer node data paths between neighboring peer nodes of the plurality of selected storage nodes arranged in a ring topology;
allocating portions of storage available at each selected storage node as logical storage units;
assigning logical storage units allocated at each selected storage node to a logical storage group spanning the plurality of selected storage nodes;
dividing, by a client node among the plurality of peer nodes, a data object at the client node into a plurality of data object chunks, each data object chunk encoded by the client node as a respective plurality of data object fragments; and
distributively storing respective data object fragments of the data object from the client node of the plurality of peer storage nodes to the logical storage group enabling peer-to-peer distributed storage of the data object to the plurality of selected storage nodes.

2. The method of claim 1 further comprising monitoring at least one storage node metric selected from a group consisting of storage consumption, storage consumption rate, churn time, churn frequency, average online time, geographic location, security level, usage pattern, software version and hardware capability.

3. The method of claim 2 wherein assigning storage units allocated at each selected storage node to a logical storage group to distributively store respective fragments of the data object from the client node of the plurality of peer nodes to the logical storage group enabling distributed storage of the data object to the storage nodes selected from the plurality of peer nodes comprises at least one of:
preferring storage nodes with low storage consumption over storage nodes with high storage consumption;
preferring storage nodes with low storage consumption rates over storage nodes with high storage consumption rates;
preferring storage nodes with a favorable security metric;
matching node consumption rates with node usage patterns to improve network efficiency and response time;
grouping storage nodes in one of a plurality of tiers based on storage node stability; and
assigning storage units to the logical storage group according to the geographic location of the storage nodes at which the respective storage units are allocated.

4. The method of claim 2 wherein assigning storage units allocated at each selected storage node to a logical storage group to distributively store respective fragments of the data object from the client node of the plurality of peer nodes to the logical storage group enabling distributed storage of the data object to the storage nodes selected from the plurality of peer nodes further comprises assigning to the logical storage group nodes selected from a plurality of geographic areas.

5. The method of claim 1 further comprising:
receiving a request from a first storage node in a first logical storage group to communicate with a second storage node in a second logical storage group;
querying a management server managing the second logical storage group to initiate communications with the second storage node in the second logical storage group;
receiving the second storage node as a member of the first logical storage group to support peer to peer communication between the first storage node in the first logical storage group and the second storage node in the second logical storage group; and
releasing the second storage node from the first logical storage group.

6. The method of claim 1 further comprising:
issuing an encrypted timed token to the client node;
receiving a token from a peer node of the client node; and
validating the received token.

7. The method of claim 6 wherein the token comprises an identifier that uniquely identifies a user of the client node, an identifier that uniquely identifies the client node, a timestamp and a storage quota associated with the user;
wherein receiving further comprises receiving an identifier that uniquely identifies a node that initiated a write transaction, the size of the write transaction, and an identifier associated with the write transaction after the write transaction has completed at the storage node; and
wherein validating the received token comprises allowing the client node access according to the validity of the token.

8. The method of claim 7 wherein allowing the client node access according to the validity of the token comprises:
including the client node on a black list if the identifier that uniquely identifies the user of the client node is invalid or the identifier that uniquely identifies the node that initiated the write transaction does not match the identifier that uniquely identifies the client node included in the token;
including the client node on a quota violation list if the user of the client node is over storage quota or if the token times out; and
updating the user's storage quota if the token is valid.

9. The method of claim 1 wherein the data object is a video file, the method further comprising:
generating a mapping describing time offset values of each chunk of the video file;
receiving a seek request including a time offset value;
determining the appropriate chunk of the video file from the mapping according to the received time offset value; and
returning the appropriate chunk of the video file.

10. A method comprising:
dividing a data object into a plurality of data object chunks at a client node among a plurality of peer nodes, the plurality of selected storage nodes arranged in a star topology with and under control of a management server over respective management server-to-peer node management paths, the management server configured to establish and manage peer node-to-peer node data paths between neighboring peer nodes of the plurality of selected storage nodes arranged in a ring topology;
encoding each data object chunk as a respective plurality of data object fragments;
creating, by the management server, a logical storage group spanning the plurality of selected storage nodes comprising a plurality of storage units assigned to the logical storage group, each storage unit comprising a portion of storage at a respective storage node of a plurality of storage nodes selected from the plurality of peer nodes and managed by the management server, each storage unit allocated to store a data object fragment at its respective storage node; and
storing each respective plurality of fragments to a respective logical storage group to distributively store respective data object fragments of the data object to the logical storage group enabling peer-to-peer distributed storage of the data object to the plurality of selected storage nodes.

11. The method of claim 10 wherein storing each respective plurality of fragments to a respective logical storage group includes coding the fragments to the storage nodes comprising the logical storage group using a duplication pattern in a ring topology.

12. The method of claim 10 further comprising:
receiving an encrypted timed token from the management server;
storing the token with each fragment; and
forwarding the received encrypted timed token to the management server for validation at times not constrained by the storing of a fragment.

13. A computer program product having a non-transitory computer readable storage medium operable to store computer program logic embodied in computer program code encoded thereon for managing a data object, the computer program code comprising:
computer program code for selecting a plurality of storage nodes among a plurality of peer nodes, the plurality of selected storage nodes arranged in a star topology with and under control of a management server over respective management server-to-peer node management paths, the management server configured to establish and manage peer node-to-peer node data paths between neighboring peer nodes of the plurality of selected storage nodes arranged in a ring topology;
computer program code for allocating portions of storage available at each selected storage node as logical storage units;
computer program code for assigning logical storage units allocated at each selected storage node to the a storage group spanning the plurality of selected storage nodes;
computer program code for dividing, by a client node among the plurality of peer nodes, a data object at the client node into a plurality of data object chunks, each data object chunk encoded by the client node as a respective plurality of data object fragments; and
computer program code for distributively storing respective data object fragments of the data object from the client node of the plurality of peer node to the logical storage group enabling peer-to-peer distributed storage of the data object to the plurality of selected storage nodes.

14. The computer program product of claim 13 further comprising computer program code for monitoring at least one storage node metric selected from a group consisting of storage consumption, storage consumption rate, churn time, churn frequency, average online time, geographic location, security level, usage pattern, software version and hardware capability.

15. The computer program product of claim 14 wherein computer program code for assigning storage units allocated at each selected storage node to a logical storage group to distributively store respective fragments of the data object from the client node of the plurality of peer nodes to the logical storage group enabling distributed storage of the data object to the storage nodes selected from the plurality of peer nodes comprises at least one of:
computer program code for preferring storage nodes with low storage consumption over storage nodes with high storage consumption;
computer program code for preferring storage nodes with low storage consumption rates over storage nodes with high storage consumption rates;
computer program code for preferring storage nodes with a favorable security metric;
computer program code for matching node consumption rates with node usage patterns to improve network efficiency and response time;
computer program code for grouping storage nodes in one of a plurality of tiers based on storage node stability; and
computer program code for assigning storage units to the logical storage group according to the geographic location of the storage nodes at which the respective storage units are allocated.

16. The computer program product of claim 14 wherein computer program code for assigning storage units allocated at each selected storage node to a logical storage group to distributively store respective fragments of the data object from the client node of the plurality of peer nodes to the logical storage group enabling distributed storage of the data object to the storage nodes selected from the plurality of peer nodes further comprises computer program code for assigning to the logical storage group nodes selected from a plurality of geographic areas.

17. The computer program product of claim 13 further comprising:
computer program code for receiving a request from a first storage node in a first logical storage group to communicate with a second storage node in a second logical storage group;
computer program code for querying a management server managing the second logical storage group to initiate communications with the second storage node in the second logical storage group;
computer program code for receiving the second storage node as a member of the first logical storage group to support peer to peer communication between the first storage node in the first logical storage group and the second storage node in the second logical storage group; and
computer program code for releasing the second storage node from the first logical storage group.

18. The computer program product of claim 13 further comprising:
computer program code for issuing an encrypted timed token to the client node;
computer program code for receiving a token from a peer node of the client node; and
computer program code for validating the received token.

19. The computer program product of claim 18 wherein the token comprises an identifier that uniquely identifies a user of the client node, an identifier that uniquely identifies the client node, a timestamp and a storage quota associated with the user;
wherein computer program code for receiving further comprises computer program code for receiving an identifier that uniquely identifies a node that initiated a write transaction, the size of the write transaction, and an identifier associated with the write transaction after the write transaction has completed at the storage node; and
wherein computer program code for validating the received token comprises computer program code for allowing the client node access according to the validity of the token.

20. The computer program product of claim 19 wherein computer program code for allowing the client node access according to the validity of the token comprises:
computer program code for including the client node on a black list if the identifier that uniquely identifies the user of the client node is invalid or the identifier that uniquely identifies the node that initiated the write transaction does not match the identifier that uniquely identifies the client node included in the token;
computer program code for including the client node on a quota violation list if the user of the client node is over storage quota or if the token times out; and
computer program code for updating the user's storage quota if the token is valid.

21. The computer program product of claim 13 wherein the data object is a video file, the computer program product further comprising:
computer program code for generating a mapping describing time offset values of each chunk of the video file;
computer program code for receiving a seek request including a time offset value;
computer program code for determining the appropriate chunk of the video file from the mapping according to the received time offset value; and
computer program code for returning the appropriate chunk of the video file.

22. A computer program product having a non-transitory computer readable storage medium operable to storage computer program logic embodied in computer program code encoded thereon for distributively storing a data object, the computer program code comprising:
computer program code for dividing the data object into a plurality of data object chunks at a client node among a plurality of peer nodes, the plurality of selected storage nodes arranged in a star topology with and under control of a management server over respective management server-to-peer node management paths, the management server configured to establish and manage peer node-to-peer node data paths between neighboring peer nodes of the plurality of selected storage nodes arranged in a ring topology;
computer program code for encoding each data object chunk as a respective plurality of data object fragments;
computer program code for creating, by the management server, a logical storage group spanning the plurality of selected storage nodes comprising a plurality of storage units assigned to the logical storage group, each storage unit comprising a portion of storage at a respective storage node of a plurality of storage nodes selected from the plurality of peer nodes and managed by the management server, each storage unit allocated to store a data object fragment at its respective storage node; and
computer program code for storing each respective plurality of fragments to a respective logical storage group to distributively store respective data object fragments of the data object to the logical storage group enabling peer-to-peer distributed storage of the data object to the plurality of selected storage nodes.

23. The computer program product of claim 22 wherein computer program code for storing each respective plurality of fragments to a respective logical storage group includes computer program code for coding the fragments to the storage nodes comprising the logical storage group using a duplication pattern in a ring topology.