Concurrent multiprotocol access to an object storage system

Abstract

In accordance with some aspects of the present disclosure, a non-transitory computer readable medium is disclosed. The non-transitory computer readable medium includes instructions when executed by a processor cause the processor to write an object to an object store using an object-based access protocol, look up the object from the object store using a file-based access protocol, and create one or more directories on-demand in the object store.

Description

CROSS-REFERENCE TO RELATED APPLICATION

This application is related to and claims priority under 35 U.S. § 119(a) the Indian Patent Application No. 202041051474, filed Nov. 26, 2020, titled “CONCURRENT MULTIPROTOCOL ACCESS TO AN OBJECT STORAGE SYSTEM,” the entire contents of which are incorporated herein by reference for all purposes.

BACKGROUND

The following description is provided to assist the understanding of the reader.

Virtual computing systems are widely used in a variety of applications. Virtual computing systems include one or more host machines running one or more virtual machines and other entities (e.g., containers) concurrently. Modern virtual computing systems allow several operating systems and several software applications to be safely run at the same time, thereby increasing resource utilization and performance efficiency. However, the present-day virtual computing systems have limitations due to their configuration and the way they operate.

SUMMARY

In accordance with some aspects of the present disclosure, a non-transitory computer readable medium is disclosed. In some embodiments, the non-transitory computer readable medium includes instructions when executed by a processor cause the processor to write an object to an object store using an object-based access protocol, look up the object from the object store using a file-based access protocol, and create one or more directories on-demand in the object store.

In accordance with some aspects of the present disclosure, an apparatus is disclosed. In some embodiments, the apparatus includes a processor and a memory. In some embodiments, the memory includes programmed instructions that, when executed by the processor, cause the apparatus to write an object to an object store using an object-based access protocol, look up the object from the object store using a file-based access protocol, and create one or more directories on-demand in the object store.

In accordance with some aspects of the present disclosure, a method is disclosed. In some embodiments, the method includes writing an object to an object store using an object-based access protocol, looking up the object from the object store using a file-based access protocol, and creating one or more directories on-demand in the object store.

The foregoing summary is illustrative only and is not intended to be in any way limiting. In addition to the illustrative aspects, embodiments, and features described above, further aspects, embodiments, and features will become apparent by reference to the following drawings and the detailed description.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an example block diagram of an object store system with file-based access, in accordance with some embodiments of the present disclosure.

FIGS. 2A-2B are an example flowchart of a method, in accordance with some embodiments of the present disclosure.

FIG. 3 is an example flowchart of a method, in accordance with some embodiments of the present disclosure.

FIG. 4 is an example flowchart of a method, in accordance with some embodiments of the present disclosure.

FIG. 5 is an example flowchart of a method, in accordance with some embodiments of the present disclosure.

The foregoing and other features of the present disclosure will become apparent from the following description and appended claims, taken in conjunction with the accompanying drawings. Understanding that these drawings depict only several embodiments in accordance with the disclosure and are therefore, not to be considered limiting of its scope, the disclosure will be described with additional specificity and detail through use of the accompanying drawings.

DETAILED DESCRIPTION

In the following detailed description, reference is made to the accompanying drawings, which form a part hereof. In the drawings, similar symbols typically identify similar components, unless context dictates otherwise. The illustrative embodiments described in the detailed description, drawings, and claims are not meant to be limiting. Other embodiments may be utilized, and other changes may be made, without departing from the spirit or scope of the subject matter presented here. It will be readily understood that the aspects of the present disclosure, as generally described herein, and illustrated in the figures, can be arranged, substituted, combined, and designed in a wide variety of different configurations, all of which are explicitly contemplated and made part of this disclosure.

A workload in a virtualized environment can be configured to run software-defined object storage service. The workload (e.g., virtual machines, containers, etc.) may be configured to deploy (e.g., create) buckets, add objects to the buckets, lookup the objects, version the objects, maintain the lifecycle of the objects, delete the objects, delete the buckets, and the like. A bucket is like a folder except that a bucket has a flat hierarchy, whereas a folder has recursion (e.g., sub-folders). The buckets can be backed by physical storage resources that are exposed through a hypervisor. An object can be anything: a file, a document, a spreadsheet, a video, a data, metadata, etc.

Customers want the ability to use files to access objects that are stored in an object store. Some systems use a separate gateway appliance/layer that converts a file-based access to object access. However, these systems require that customers manage independent entities and independent namespaces, including temporarily creating a file in a file name space, then synchronizing (syncing) the file name space with the object store using an object application programming interface (API). These systems do not allow customers to leverage many of the object features such as writing objects partially, overwriting objects, and extending objects. In addition, there is added latency that comes with syncing the namespaces and accessing the object store. Moreover, the object store is not scalable—the gateway layer becomes the bottleneck as the capacity of the object store grows.

The present disclosure is generally directed to implementing file-based access protocols natively in the object store. Users can access objects with object protocol or file-based access protocol. Examples of file-based access protocol include network file system (NFS) protocol and server message block (SMB) protocol. The object store can include a unified namespace so there are no sync/cache coherency/consistency issues. The object store with embedded file-based access protocol can reduce latency as compared with gateway layer implementations. The object store can be scalable. Directories may be created on the fly, when access requests are made, so that unnecessary resources are not consumed. In some embodiments, the present disclosure receives an access request in file-based access protocol, identifies an object name, parses the name to identify directory names, and automatically creates intermediate directories. In some embodiments, the present disclosure determines that an object has been deleted, and automatically deletes the intermediate directories.

FIG. 1 is an example block diagram of an object store system 100 with file-based access, in accordance with some embodiments of the present disclosure. The object store system 100 includes the object controller 102, which manages object data and coordinates metadata updates with a metadata server 112.

The object controller 102 includes an object store command processor 106. The object store command processor 106 can process a command (e.g., request) using an object store protocol. The object store command processor 106 can receive the command at a first port of the object controller 102. Examples of object store protocols are S3 and Swift.

In some embodiments, the object store command processor 106 receives object write requests. In some embodiments, in receiving a write request, the object store command processor 106 instructs an object store interface 108 to write the object in an object store 110 (e.g., in a specified bucket). For example, the object store command processor 106 sends an instruction to the object store interface 108 to write object data of the object “A/B/C/foo.object.” The object an also be referred to as the object name or the path name. The object store command processor 106 or the object store interface 108 can send an instruction to the metadata server 112 to create metadata for the object. The metadata server 112 can create and store the metadata in a memory or storage (e.g., log-structured memory). The object store command processor 106 can return an acknowledgement to the client that the object has been written.

In some embodiments, the object store command processor 106 receives object lookup (e.g., read) requests. As part of receiving a lookup request, the object store command processor 106 can receive an object (e.g., the object “A/B/C/foo.object”). The object store command processor 106 can send the object to the metadata server 112. Here, “AB/C” can be referred to as a prefix. The metadata server 112 can determine the corresponding metadata for the object, construct a file handle based on the object, and send the file handle back to the object store interface 108. In some embodiments, the metadata server 112 has a mapping data structure that maps the object to the file handle and the metadata server 112 can look up the file handle by locating the object in an index (e.g., row) in the mapping data structure and fetching the corresponding file handle at the same index. The object store interface 108 can fetch the object data from the object store 110 using the file handle and send the object data back to the object store command processor 106. The object store command processor 106 can return the object data to the client.

The object controller 102 includes the file system command processor 104. The file system command processor 104 can process a command using a file-based access protocol. In some embodiments, the command includes one or more arguments such as an object (e.g., a file name), a directory (e.g., a directory name), a file handle (e.g., cookie, opaque cookie, alias) of an object, a bucket, a file handle of a bucket, or an operation (e.g., create, lookup, delete). The namespace can be unified (e.g., a file handle of an object can be the same regardless of the protocol). The file system command processor 104 can receive the command at a second port of the object controller 102. The second port can be different from the first port.

In some embodiments, the file system command processor 104 receives write requests.

The file system command processor 104 can instruct the object store interface 108 to store the file in the object store 110. In some embodiments, the file is stored in the object store 110. In some embodiments, the file system command processor 104 creates, or instructs the object store interface 108 or the metadata server 112 to create, directories upon the file being created. In some embodiments, inodes (metadata) are created for the directories and files and stored in the storage/memory associated with the metadata server 112.

In some embodiments, the file system command processor 104 receives file (e.g., object) or directory lookup requests. In receiving a lookup request for a directory, the file system command processor 104 can receive a directory name. If the file system command processor 104 receives a directory name, and the directory exists (e.g., the metadata for the directory exists), the file system command processor 104 can return the directory file handle.

Upon receiving a directory name, the file system command processor 104 can determine if a directory file handle associated with the directory name exists. For example, if the file system command processor 104 receives the directory “A,” the file system command processor 104 determines whether a file handle associated with “A” exists. The determination can be done by looking up the inode for “A” in the metadata server. If an inode exists, the file system command processor 104 can fetch the file handle. If the inode does not exist, the file system command processor 104 determines that the file handle does not exist.

In some embodiments, the file system command processor 104 creates the directory based on determining that (a) the directory does not exist and (b) a prefix of an existing object includes the directory. That is, the file system command processor 104 can create the directory structure on-demand. The on-demand creation of a directory can be referred to as an implicitly created directory. Entire directory structures (e.g., one or more directories arranged in a hierarchy) can be created on-demand. For example, if an object “A/B/C/foo.object” exists, and the file system command processor 104 determines the directory “A” does not exist, upon a lookup request of “A,” the file system determines that “A” is in the prefix of the object “A/B/C/foo.object.” In some embodiments, file system command processor 104 parses “A/B/C/foo.object” to identify “A.” Based on identifying “A,” the file system command processor 104 can create the directory “A” or instruct the object store interface 108 or metadata server 112 to create the directory “A.” In some embodiments, in creating the directory “A,” the file system command processor 104 creates/instructs creation of metadata from which a file handle can be fetched/retrieved. Then, the file system command processor 104 can fetch and return the file handle to the client.

In the same regard, if an object “A/B/C/foo.object” exists, and the file system command processor 104 receives a request for “B,” the file system command processor 104 can parse “A/B/C/foo.object” to identify “A” and “B.” So long as “A” exists, the file system command processor creates “B.”

However, if a directory does not exist and a prefix of an object does not include the directory, the file system command processor 104 can return an error to the client. For example, if an object “A/B/C/foo.object” exists, and the file system command processor 104 receives a request for the directory “D,” the file system command processor 104 returns an error.

In receiving a lookup request for a file, the file system command processor 104 can receive a file handle (e.g., of the root, the bucket, or a parent folder) corresponding with a file. If the file system command processor 104 receives a file handle, the file system command processor 104 can look up the file in the object store 110 (or via the object store interface 108 or the metadata server 112). The file system command processor 104 can fetch the file and return the file to the client.

The file system command processor 104 can automatically delete (e.g., garbage collects) the implicitly created directories when the object which is responsible for their automatic creation is deleted. For example, if the object “A/B/C/foo” is deleted, a directory structure “AB/C” exists, and no other objects are using the same directory, the file system command processor 104 automatically deletes the implicitly created directories. In some embodiments, one or more of the metadata or the file handle of the deleted directory gets deleted.

Once the object and the corresponding directories are deleted, a lookup of the corresponding directories can return an error (unless other existing objects are in the same directories). For example, if “A/B/C/foo” is deleted, and as a result, “A” is deleted, then, upon receiving a request for “A,” the file system command processor 104 determines that “A” does not exist in any prefix of any object, and the file system command processor 104 returns an error to the client.

In some embodiments, the object file handle is a persistent file handle. As a result, the implicitly created directories are can be accessed through the persistent file handle even after some event that would reset any temporary configurations. For example, if after file system command processor 104 receives the file handle, the object store 110 restarts, the object remains accessible through the same file handle.

The file system command processor 104 supports versioning. In some embodiments, the file system includes snapshots of an object. The file system command processor 104 can take a snapshot every time the object is written to and map the snapshot to a corresponding version. The mapping can be stored in the object store 110. Upon receiving a request for a snapshot, the file system command processor 104 (or the object store 110) can fetch the map to determine the version of the object corresponding to the snapshot.

The file system command processor 104 supports WORM (write once read many) functionality. The file system command processor 104 can support out of order first writes over a file-based access of the object store 110. The file system command processor 104 can support writes over a file-based access of the object store 110. The file system command processor 104 can support overwrites over a file-based access of the object store 110.

In some embodiments, the object controller 102 includes the object store interface 108 in communication with the file system command processor 104 and the object store command processor 106. The object store interface 108 may interface between each of the processors 104 and 106, the object store 110, and other services. In some embodiment, the object store interface 108 receives an instruction based on the command (e.g., in a first format) and sends an instruction to the object store 110 (e.g., in a second format, wherein the second format is translated from the first format).

In some embodiments, the object store system 100 includes the object store 110 in communication with the object store interface 108. In some embodiments, the object store 110 includes the object that the command operates on. In some embodiments, the object store includes buckets, and each of the buckets are configured to store objects. The object store 110 may include, but is not limited to temporary memory device such as a random access memory (RAM) device and/or non-volatile memory (NVM, e.g., persistent memory) such as non-volatile dual in-line memory modules (NVDLMM), a read only memory (ROM) device, any type of magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips, etc.), optical disks (e.g., compact disk (CD), digital versatile disk (DVD), etc.), smart cards, solid state devices, etc.

In some embodiments, the object store system 100 includes the metadata server 112 in communication with the object store interface 108. The metadata server 112 can contain some or all of the metadata around an object store deployment. In some embodiments, the metadata server 112 leverages a key-value store for storage of the metadata.

In some embodiments, the object store system 100 includes a life cycle server 114. The life cycle server 114 can control life cycle management, audits, and background maintenance activities.

Each of the components (e.g., elements, entities) of the system 100 (e.g., the object controller 102, the file system command processor 104, the object store command processor 106, the object store interface 108, the object store 110, and the metadata server 112, the life cycle server 114), is implemented using hardware, software, or a combination of hardware or software, in one or more embodiments. Each of the components of the system 100 may be a processor with instructions or an apparatus/device (e.g., server) including a processor with instructions, in some embodiments. In some embodiments, multiple components (e.g., the discovery engine 160 and the cloud control plane 180) may be part of a same apparatus and/or processor. Each of the components of the system 100 can include any application, program, library, script, task, service, process or any type and form of executable instructions executed by one or more processors, in one or more embodiments. Each of the one or more processors is hardware, in some embodiments. The instructions may be stored on one or more computer readable and/or executable storage media including non-transitory storage media.

In some embodiments, the object store may be integrated with, or run on top of, a hyper-converged infrastructure (HCl) cluster (e.g., HCl, HCl cluster, cluster, etc.). An HCl cluster is one or more virtualized workloads (one or more virtual machines, containers, etc.) that run services/applications/operating systems by using storage and compute resources of one or more nodes (e.g., hosts, computers) which are virtualized through a hypervisor. Thus, the cluster refers to the cluster of physical nodes as well as the cluster of workloads. The cluster can be located in one node, distributed across multiple nodes in one data center (on-premises) or cloud, or distributed across multiple data centers, multiple clouds or data center-cloud hybrid. At least one of the workloads (e.g., a controller virtual machine or container) in the cluster runs core services that manages and maintains the cluster, including a cluster manager, a health/wellness check manager, an I/O storage manager, and the like. In some embodiments, a workload manages multiple clusters.

Sparse files, overwrites, and extending writes can be handled by the object store system 100. In some embodiments, a sparse file is created when some offset of a file is not written to and instead skipped over before writing to higher offsets. For such cases, the object store only allocates the containing block (e.g., the part of the file that was written to) in the object store. Through a simple buddy scheme, the system can efficiently handle extending writes. For example, assuming 5 TiB is the maximum ObjectSize: Small Objects: 9 entries. Size of Location Identifier entries: 8 KiB+8 KiB+16 KiB+32 KiB+64 KiB+128 KiB+256 KiB+512 KiB+1 MiB. Large Objects: 10 (upto 1 GiB)+5119 (rest of the 5 TiB)=5129. Size of location Identifier entries: 2 MiB+2 MiB+4 MiB+8 MiB+16 MiB+32 MiB+64 MiB+128 MiB+256 MiB+512 MiB+1 GiB+1 GiB. Overwrites are handled by writing in place if versioning is disabled. If versioning is enabled, new versions can be created by using internal object copy functionality.

In some embodiments, objects are replicated independently by virtue of the fact that a directory superstructure can be automatically derived on the target. The writes to a file can trickle in one block at a time so it can be better to wait until the entire file has been written before the object store system 100 can start the replication. Otherwise the object store system 100 can determine the offset that needs to be replicated. The object store system 100 can record that a file is being written and would be replicated when the file has been written. When the file has been written, the object controller (OC) 102 can initiate replication and mark the file as done when replication finishes. The file-based access protocol may not maintain MD5 checksums. If new writes come in while replication is going on, the object store system 100 can restart replication. The object store system 100 can replicate only the metadata.

Referring now to FIGS. 2A-2B, a flowchart of an example method 200 is illustrated, in accordance with some embodiments of the present disclosure. The method 200 may be implemented using, or performed by, the object store system 100, one or more components of the object store system 100, or a processor associated with object store system 100 or the one or more components of object store system 100. Additional, fewer, or different operations may be performed in the method 200 depending on the embodiment.

A processor (e.g., the object controller 102, the file system command processor 104, the object store command processor 106, or a combination thereof) writes an object in an object store using an object-based access protocol (202). The processor receives a lookup request of a directory using a file-based access protocol (204). The processor determines whether the directory exists (206). If the processor determines that the directory does not exist, the processor creates the directory (208) and proceeds to operation 210. If the processor determines that the directory exists, the processor descends into the directory (210).

The processor determines whether the next lookup request is for a directory (212). If the processor determines whether the next lookup request is for a directory, the processor returns to operation 204. If the processor determines whether the next lookup request is not for a directory (e.g., the next lookup request is for an object), the processor receives the lookup request of the object, wherein the lookup request uses a file-based access protocol (214). The processor associates the object with the directories that the processor has descended into (e.g., the directory path) (216). The processor returns the object in response to the lookup request (218). In some embodiments, in subsequent lookup requests for the same object, the processor descends into the same directory path to return the object.

In some embodiments, the processor implements a unified namespace for the file-based access and the object-based access. Namespace is described in further detail with respect to FIG. 3. In some embodiments, the processor enables object features like versioning and WORM for file-based access. Object features are described in further detail with respect to FIG. 4. In some embodiments, if the object is deleted, the processor deletes the one or more directories. Deletion (e.g., on-demand deletion) of directories is described in further detail with respect to FIG. 5.

The method 200 has various benefits. One benefit is that the directories are created on-demand. This feature is critical for big data and analytics use cases, where terabytes of data are stored in an object store. Typical systems needlessly consume large amount of memory and compute resources creating directories when the data may be infrequently accessed or never accessed at all. Advantageously, the method 200 creates the directories when the user/client sends a lookup request. This minimizes the resources that are consumed while still providing the user with NFS access of an object store.

Referring now to FIG. 3, a flowchart of an example method 300 is illustrated, in accordance with some embodiments of the present disclosure. The method 300 may be implemented using, or performed by, the object store system 100, one or more components of the object store system 100, or a processor associated with object store system 100 or the one or more components of object store system 100. Additional, fewer, or different operations may be performed in the method 300 depending on the embodiment. In some embodiments, one or more operations of the method 300 can be combined with one or more operations of the method 200.

A processor (e.g., the object controller 102, the file system command processor 104, the object store command processor 106, or a combination thereof) performs a first operation (e.g., write, lookup, delete, etc.) an object using an object based access protocol in a unified namespace (302). The processor performs a second operation (e.g., write, lookup, delete, etc.) on an object using a file-based access protocol in the unified namespace (304). Thus, the namespace is unified. Advantageously, this allows multiple clients to use different protocols and still have instantaneous access to the same namespace and data.

Referring now to FIG. 4, a flowchart of an example method 400 is illustrated, in accordance with some embodiments of the present disclosure. The method 400 may be implemented using, or performed by, the object store system 100, one or more components of the object store system 100, or a processor associated with object store system 100 or the one or more components of object store system 100. Additional, fewer, or different operations may be performed in the method 400 depending on the embodiment. In some embodiments, one or more operations of the method 400 can be combined with one or more operations of the methods 200-300.

A processor (e.g., the object controller 102, the file system command processor 104, the object store command processor 106, or a combination thereof) writes an object using an object-based access protocol and object features such as versioning and write-once-read-many (WORM) (402). The processor looks up an object using a file-based access protocol and the same object features (404). In some embodiments, the processor enables such features over the file-based access protocol to provide best of both worlds for legacy applications wanting to consume storage using traditional file access protocols but require administration convenience of objects

Referring now to FIG. 5, a flowchart of an example method 500 is illustrated, in accordance with some embodiments of the present disclosure. The method 500 may be implemented using, or performed by, the object store system 100, one or more components of the object store system 100, or a processor associated with object store system 100 or the one or more components of object store system 100. Additional, fewer, or different operations may be performed in the method 500 depending on the embodiment. In some embodiments, one or more operations of the method 500 can be combined with one or more operations of the methods 200, 300, or 400.

A processor (e.g., the object controller 102, the file system command processor 104, the object store command processor 106, or a combination thereof) determines that an object is deleted or that an object is scheduled to be deleted (502). In some embodiments, the processor receives an indication as such from another component (e.g., the object store interface 108 or the object store 110). In some embodiments, the processor determines that a directory structure through which the object is accessed exists (504). In some embodiments, the processor determines that the directory structure is dedicated to the object (e.g., there is no other object accessed through the same directory structure). If the object is deleted, the processor deletes the directory structure (506). If the object is scheduled to be deleted, the processor deletes the directory structure when the object is deleted (508).

The herein described subject matter sometimes illustrates different components contained within, or connected with, different other components. It is to be understood that such depicted architectures are merely exemplary, and that in fact many other architectures can be implemented which achieve the same functionality. In a conceptual sense, any arrangement of components to achieve the same functionality is effectively “associated” such that the desired functionality is achieved. Hence, any two components herein combined to achieve a particular functionality can be seen as “associated with” each other such that the desired functionality is achieved, irrespective of architectures or intermedial components. Likewise, any two components so associated can also be viewed as being “operably connected,” or “operably coupled,” to each other to achieve the desired functionality, and any two components capable of being so associated can also be viewed as being “operably couplable,” to each other to achieve the desired functionality. Specific examples of operably couplable include but are not limited to physically mateable and/or physically interacting components and/or wirelessly interactable and/or wirelessly interacting components and/or logically interacting and/or logically interactable components.

With respect to the use of substantially any plural and/or singular terms herein, those having skill in the art can translate from the plural to the singular and/or from the singular to the plural as is appropriate to the context and/or application. The various singular/plural permutations may be expressly set forth herein for sake of clarity.

It will be understood by those within the art that, in general, terms used herein, and especially in the appended claims (e.g., bodies of the appended claims) are generally intended as “open” terms (e.g., the term “including” should be interpreted as “including but not limited to,” the term “having” should be interpreted as “having at least,” the term “includes” should be interpreted as “includes but is not limited to,” etc.). It will be further understood by those within the art that if a specific number of an introduced claim recitation is intended, such an intent will be explicitly recited in the claim, and in the absence of such recitation no such intent is present. For example, as an aid to understanding, the following appended claims may contain usage of the introductory phrases “at least one” and “one or more” to introduce claim recitations. However, the use of such phrases should not be construed to imply that the introduction of a claim recitation by the indefinite articles “a” or “an” limits any particular claim containing such introduced claim recitation to inventions containing only one such recitation, even when the same claim includes the introductory phrases “one or more” or “at least one” and indefinite articles such as “a” or “an” (e.g., “a” and/or “an” should typically be interpreted to mean “at least one” or “one or more”); the same holds true for the use of definite articles used to introduce claim recitations. In addition, even if a specific number of an introduced claim recitation is explicitly recited, those skilled in the art will recognize that such recitation should typically be interpreted to mean at least the recited number (e.g., the bare recitation of “two recitations,” without other modifiers, typically means at least two recitations, or two or more recitations). Furthermore, in those instances where a convention analogous to “at least one of A, B, and C, etc.” is used, in general such a construction is intended in the sense one having skill in the art would understand the convention (e.g., “a system having at least one of A, B, and C” would include but not be limited to systems that have A alone, B alone, C alone, A and B together, A and C together, B and C together, and/or A, B, and C together, etc.). In those instances where a convention analogous to “at least one of A, B, or C, etc.” is used, in general such a construction is intended in the sense one having skill in the art would understand the convention (e.g., “a system having at least one of A, B, or C” would include but not be limited to systems that have A alone, B alone, C alone, A and B together, A and C together, B and C together, and/or A, B, and C together, etc.). It will be further understood by those within the art that virtually any disjunctive word and/or phrase presenting two or more alternative terms, whether in the description, claims, or drawings, should be understood to contemplate the possibilities of including one of the terms, either of the terms, or both terms. For example, the phrase “A or B” will be understood to include the possibilities of “A” or “B” or “A and B.” Further, unless otherwise noted, the use of the words “approximate,” “about,” “around,” “substantially,” etc., mean plus or minus ten percent.

The foregoing description of illustrative embodiments has been presented for purposes of illustration and of description. It is not intended to be exhaustive or limiting with respect to the precise form disclosed, and modifications and variations are possible in light of the above teachings or may be acquired from practice of the disclosed embodiments. It is intended that the scope of the invention be defined by the claims appended hereto and their equivalents.

Claims

1. A non-transitory computer readable medium comprising instructions that, when executed by a processor, cause the processor to: write an object to a bucket of an object store using an object-based access protocol in a unified namespace, wherein the bucket is backed by a virtualized physical storage resource; andin response to a request to look up the object using a file-based access protocol in the unified namespace, look up the object from the object store and create one or more directories on-demand in the object store.

2. The medium of claim 1, further comprising instructions that, when executed by the processor, cause the processor to parse the object to identify the one or more directories.

3. The medium of claim 1, further comprising instructions that, when executed by the processor, cause the processor to determine whether a directory of the one or more directories exists based on a prefix of the object.

4. The medium of claim 3, further comprising instructions that, when executed by the processor, cause the processor to create the directory in memory in response to determining that the directory does not exist.

5. The medium of claim 3, further comprising instructions that, when executed by the processor, cause the processor to descend into the directory in response to creating the directory.

6. The medium of claim 1, further comprising instructions that, when executed by the processor, cause the processor to delete the one or more directories in response to determining that the object is deleted.

7. The medium of claim 1, wherein the unified namespace is used by a plurality of clients connected to a network.

8. The medium of claim 1, wherein looking up the object using the file-based protocol does not require synchronizing the unified namespace with the object store.

9. The medium of claim 1, wherein writing the object to the bucket of the object store using the object-based access protocol includes writing the object with a file handle, and wherein looking up the object using the file-based access protocol includes looking up the object with the file handle.

10. An apparatus comprising a processor and a memory, wherein the memory includes programmed instructions that, when executed by the processor, cause the apparatus to: write an object to a bucket of an object store using an object-based access protocol in a unified namespace, wherein the bucket is backed by a virtualized physical storage resource; andin response to a request to look up the object using a file-based access protocol in the unified namespace, look up the object from the object store and create one or more directories on-demand in the object store.

11. The apparatus of claim 10, wherein the memory further includes programmed instructions that, when executed by the processor, cause the apparatus to parse the object to identify the one or more directories.

12. The apparatus of claim 10, wherein the memory further includes programmed instructions that, when executed by the processor, cause the apparatus to determine whether a directory of the one or more directories exists based on a prefix of the object.

13. The apparatus of claim 12, wherein the memory further includes programmed instructions that, when executed by the processor, cause the apparatus to create the directory in memory in response to determining that the directory does not exist.

14. The apparatus of claim 12, wherein the memory further includes programmed instructions that, when executed by the processor, cause the apparatus to descend into the directory in response to creating the directory.

15. The apparatus of claim 10, wherein the memory further includes programmed instructions that, when executed by the processor, cause the apparatus to delete the one or more directories in response to determining that the object is deleted.

16. The apparatus of claim 10, wherein the unified namespace is used by a plurality of clients connected to a network.

17. The apparatus of claim 10, wherein looking up the object using the file-based protocol does not require synchronizing the unified namespace with the object store.

18. The apparatus of claim 10, wherein writing the object to the bucket of the object store using the object-based access protocol includes writing the object with a file handle, and wherein looking up the object using the file-based access protocol includes looking up the object with the file handle.

19. A computer-implemented method comprising: writing an object to a bucket of an object store using an object-based access protocol in a unified namespace, wherein the bucket is backed by a virtualized physical storage resource; andin response to a request to look up the object using a file-based access protocol in the unified namespace, looking up the object from the object store and creating one or more directories on-demand in the object store.

20. The method of claim 19, further comprising parsing the object to identify the one or more directories.

21. The method of claim 19, further comprising determining whether a directory of the one or more directories exists based on a prefix of the object.

22. The method of claim 21, further comprising creating the directory in memory in response to determining that the directory does not exist.

23. The method of claim 19, further comprising deleting the one or more directories in response to determining that the object is deleted.

24. The method of claim 19, wherein the unified namespace is used by a plurality of clients connected to a network.

25. The method of claim 19, wherein looking up the object using the file-based protocol does not require synchronizing the unified namespace with the object store.

26. The method of claim 19, wherein writing the object to the bucket of the object store using the object-based access protocol includes writing the object with a file handle, and wherein looking up the object using the file-based access protocol includes looking up the object with the file handle.