# Patent

## Title
File system management with enhanced searchability

## Abstract

A primary (e.g., master) file system stores multiple files and corresponding metadata. A view generator function receives template information (e.g., view configuration information) specifying types of metadata information associated with the multiple files stored in the primary file system. Based on processing of the metadata information in the primary file system as specified by the template information, the generator function produces metadata for inclusion in a secondary file system, which is used to satisfy search inquiries associated with the multiple files stored in the primary file system. According to one arrangement, the generator function replicates metadata information in the primary file system as specified by the template information for inclusion in the secondary file system. The secondary file system can include metadata from other sources as well that produced by the generator function. The secondary file system enables more efficient handling of search inquiries than applying search inquiries to the master file system.

## Background
RELATED APPLICATIONS
This application is related to and claims the benefit of earlier filed U.S. Provisional Patent Application Ser. No. 60/788,851 entitled “Method and System to Generate, Maintain, and Use Application Optimized Information Views,” filed on Apr. 3, 2006, the entire teachings of which are incorporated herein by this reference.


BACKGROUND
It is currently an enormous challenge for global enterprises to manage their vast stores of digital information. Storage capacity currently grows at annual rates of 30-70% in many enterprises, so the task of scaling storage capacity is a significant challenge.
Recently, certain technologies have been developed to reduce the complexity of scaling capacity. An example of such a technology is embodied in Acopia Network's Adaptive Resource Networking Switch.
Since scaling of storage capacity is starting to be addressed, increasing attention has been focused on raising the intelligence of storage management to achieve objectives beyond scaling. Often, the easiest way to add intelligence to a storage system is use of independent applications that layer above the storage infrastructure. For example, conventional search engines can be used to index content stored in network file systems and provide an Enterprise Search capability that is similar to the search capability provided on the Internet.
SUMMARY
Unfortunately, conventional approaches to the direct application of search engine technology to Enterprise information presents a new set of challenges. For example, the conventional act of indexing network file systems can tax already burdened servers and slow critical business applications. In addition, conventional context-based indexing often suffers from a so-called “needle in the haystack” problem in which it is difficult find appropriate data to generate a response to a query or search. Thus, conventional techniques do not provide an efficient way for Enterprise users to easily find many different types of information.
Techniques discussed herein deviate with respect to conventional applications such as those discussed above as well as techniques known in the prior art. In particular, embodiments herein support consolidation of information in a primary file system for inclusion in a secondary file system optimized for performing searches associated with files stored in a primary file system.
More specifically, in one embodiment, beyond supporting mere searching, the system disclosed herein is based in part on an observation that it would be useful for enterprises to have the ability to continually (in “real-time”) align storage and management of information according to current business requirements for each specific piece of information (e.g., file). Unfortunately, the business requirements related to a particular set of digital information (e.g., file, document, content, etc.) can vary greatly over the lifetime of the information. Every piece of information can have different requirements. Therefore, a solution that addresses the challenge of managing information over its lifetime must be able to detect changes in the business requirements related to each piece of digital information and then perform any required changes to the storage and management approach at the granularity of the piece of digital information.
There is no conventional general-purpose solution to these challenges today.
In contrast to conventional methods, embodiments disclosed herein provide advancements over conventional techniques to significantly overcome the aforementioned issues. In one embodiment, information stored in a network file system is automatically converted to a form (a “view”) optimized for use by a search application. Using this optimized view of a primary file system in a secondary file system, the user of the search application can perform many types of queries against the stored information, which are much simpler to describe, faster to execute, and provide more accurate results. Based on techniques as described herein, an index to a stored file in a master file system can be generated much more quickly with much less overhead on existing storage than is possible according to conventional methods.
Accordingly, in a general embodiment as described herein includes maintaining a primary (e.g., master) file system to store multiple files and corresponding metadata. A view generator function receives template information (e.g., view configuration information) specifying types of metadata information associated with the multiple files stored in the primary file system. Based on processing of the metadata information in the primary file system as specified by the template information, the generator function produces metadata for inclusion in a secondary file system used to satisfy search inquiries associated with the multiple files stored in the primary file system.
In one embodiment, the generator function replicates metadata information in the primary file system as specified by the template information for inclusion in the secondary file system. The secondary file system (e.g., a refined version of the master file system) is then used to carry out search inquiries in a more efficient manner than applying search inquiries to the master file system.
In addition to inclusion of metadata information from a file in the master file system as specified by view configuration information (e.g., template information), the metadata information in the secondary file system can include data from a corresponding file in the primary file system. In certain embodiments, the metadata information in the secondary file system (e.g., more easily searched file system) can include information indicating different operations that have been applied to a respective file in the master file system.
In yet other embodiments, the metadata information stored in the secondary file system can include data derived from one or more sources such as content management applications that store extended metadata information about files as well as applications that analyze files and produce extended metadata.
In addition to the embodiments as discussed above, other embodiments disclosed herein include any type of computerized device, workstation, handheld or laptop computer, or the like configured with software and/or circuitry (e.g., a processor) to process any or all of the method operations disclosed herein. In other words, a computerized device such as a computer or a data communications device or any type of processor that is programmed or configured to operate as explained herein is considered an embodiment disclosed herein.
Other embodiments disclosed herein include software programs (executed by one or more servers) to perform the steps and operations summarized above and disclosed in detail below. One such embodiment comprises a computer program product that has a computer-readable medium including computer program logic encoded thereon that, when performed in a computerized device having a coupling of a memory and a processor, programs the processor to perform the operations disclosed herein. Such arrangements are typically provided as software, code and/or other data (e.g., data structures) arranged or encoded on a computer readable medium such as an optical medium (e.g., CD-ROM), floppy or hard disk or other a medium such as firmware or microcode in one or more ROM or RAM or PROM chips or as an Application Specific Integrated Circuit (ASIC). The software or firmware or other such configurations can be installed onto a computerized device to cause the computerized device to perform the techniques explained herein as embodiments disclosed herein.
In addition to the embodiments discussed above, other embodiments herein include a computerized device (e.g., a server, a host computer, workstation, etc.) configured to support the techniques disclosed herein such as creation and/or updating of routines to carry out operations with respect to a staging database and master database. In such embodiments, a computer environment to carry out the invention includes a memory system, a processor (e.g., a processing device), a respective display, and an interconnect connecting the processor and the memory system. The interconnect can also support communications with the respective display (e.g., display screen or display medium). The memory system can be encoded with an application that, when executed on a respective processor, supports content management and searching functions according to techniques herein.
Yet other embodiments of the present disclosure include software programs to perform the method embodiment and operations summarized above and disclosed in detail below in the Detailed Description section of this disclosure. More specifically, one embodiment herein includes a computer program product (e.g., a computer-readable medium). The computer program product includes computer program logic (e.g., software instructions) encoded thereon. Such computer instructions can be executed on a computerized device to manage content according to embodiments herein. For example, the computer program logic, when executed on at least one processor associated with a computing system, causes the processor to perform the operations (e.g., the methods) indicated herein as embodiments of the present disclosure. Such arrangements as further disclosed herein can be provided as software, code and/or other data structures arranged or encoded on a computer readable medium such as an optical medium (e.g., CD-ROM), floppy or hard disk, or other medium such as firmware or microcode in one or more ROM or RAM or PROM chips or as an Application Specific Integrated Circuit (ASIC). The software or firmware or other such configurations can be installed on a computerized device to cause one or more processors in the computerized device to perform the techniques explained herein.
Yet another more particular technique of the present disclosure is directed to a computer program product or computer environment that includes a computer readable medium having instructions stored thereon to facilitate management of content such as files. The instructions and corresponding execution support operations of: i) maintaining a primary file system (e.g., in a primary repository) to store multiple files; ii) receiving template information specifying types of metadata information associated with the multiple files stored in the primary file system; and iii) processing the metadata information in the primary file system as specified by the template information for production of metadata in a secondary file system (e.g., in a secondary repository) used to satisfy search inquiries associated with the multiple files stored in the primary file system.
Other embodiments include a method supporting operations of: i) receiving template information specifying types of metadata information; ii) applying the template information to a given file in a primary file system to produce a set of metadata information; and iii) storing the set of metadata information in a secondary file system information used to satisfy search inquiries associated with files stored in the primary repository.
Other embodiments of the present disclosure include hardware and/or software programs to perform any of the method embodiment steps and operations summarized above and disclosed in detail below.
It should be understood that the system disclosed herein may be embodied strictly as a software program, as software and hardware, or as hardware alone. The features disclosed herein may be employed in data communications devices and other computerized devices and software systems for such devices such as those manufactured by Acopia Networks, Inc., of Lowell, Mass.
As mentioned above, techniques herein are well suited for use in applications such as those supporting management of stored information such as file systems and/or databases. However, it should be noted that configurations herein are not limited to such use and thus configurations herein and deviations thereof are well suited for use in other environments as well.
Each of the different features, techniques, configurations, etc. discussed herein can be executed independently or in combination. Accordingly, the present invention can be embodied and viewed in many different ways.
Also, note that this summary section herein does not specify every embodiment and/or incrementally novel aspect of the present disclosure or claimed invention. Instead, this summary only provides a preliminary discussion of different embodiments and corresponding points of novelty over conventional techniques. For additional details and/or possible perspectives (permutations) of the invention, the reader is directed to the Detailed Description section and corresponding figures of the present disclosure as further discussed below. Although not exhaustive, the claims section also provides different perspectives of the invention based on matter recited in the specification.



BRIEF DESCRIPTION OF THE DRAWINGS
The foregoing and other objects, features, and advantages of the present application will be apparent from the following more particular description of preferred embodiments of the present disclosure, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, with emphasis instead being placed upon illustrating the embodiments, principles and concepts.
FIG. 1 is a diagram illustrating an example storage management system and corresponding components according to embodiments herein.
FIG. 2 is a diagram of view configuration information specifying types of data in a primary file system to a secondary file system according to embodiments herein.
FIG. 3 is a diagram of example view information (e.g., replicated and stored metadata) associated with a file according to embodiments herein.
FIG. 4 is an example screenshot of a search engine and corresponding query applied to a secondary file system for identifying one or more files in a primary file system according to embodiments herein.
FIG. 5 is an example screenshot of a query response according to embodiments herein.
FIG. 6 is a diagram of a storage management system including a logging agent according to embodiments herein.
FIG. 7 is a diagram illustrating an example record format for file operation logging according to embodiments herein.
FIG. 8 is a diagram illustrating an example format of an NFS create operation according to embodiments herein.
FIG. 9 is an example flowchart associated with a log agent illustrating generation of a log file according to embodiments herein.
FIG. 10 is an example flowchart for processing a file operation log according to embodiments herein.
FIG. 11 is a diagram illustrating an example set of file access statistics derived from a file operation log according to embodiments herein.
FIG. 12 is a diagram illustrating an example set of additional file access statistics derived by a file operation log according to embodiments herein.
FIG. 13 is a diagram of an example of metadata information associated with a deleted file according to embodiments herein.
FIG. 14 is a diagram illustrating an example storage management system according to embodiments herein.
FIG. 15 is a diagram of example code for updating indexes according to embodiments herein.
FIG. 16 is a diagram of an example composite file including multiple tag groups according to embodiments herein.
FIG. 17 is a diagram illustrating scaling of a file count limit of a search application according to embodiments herein.
FIG. 18 is a diagram illustrating an example storage management system according to embodiments herein.
FIG. 19 is a diagram of an example architecture for carrying out different functionality such as a view generator function, logging function, etc. according to embodiments herein.



DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS
In the context of an embodiment herein, a primary (e.g., master) file system stores multiple files and corresponding metadata. A generator function creates a corresponding repository (e.g., a secondary file system) used for search purposes. For example, the generator function receives template information (e.g., view configuration information) specifying types of metadata information associated with the multiple files stored in the primary file system. Based on processing of the metadata information in the primary file system as specified by the template information, the generator function produces metadata for inclusion in a secondary file system, which is used to satisfy search inquiries associated with the multiple files stored in the primary file system.
According to one arrangement, the generator function replicates metadata information in the primary file system as specified by the template information for inclusion in the secondary file system. The secondary file system (e.g., a refined version of the master file system) is then used to carry out search inquiries in a more efficient manner than applying search inquiries directly to the master file system.
FIG. 1 is a diagram illustrating an example file management system 90 according to embodiments herein. As shown, file management system 90 includes server 108, server 109, server 119, server 111, and server 112. Server 108 supports execution of application 100. Server 109 supports execution of application 101 and application 107. Server 119 supports management of file system 103. Server 112 supports management of file system 106. Server 119 supports execution of view generator function 105, which produces file system 106 based on view configuration information 104 (e.g., template information) applied to contents of file system 103. Each of the servers (in FIG. 1 and other figures) can be a computer system (e.g., as shown in FIG. 19) configured to execute software and carry out the methods as described herein. Connections between servers can include one or more network connections (e.g., a local area network, wide area network, Internet, etc.)
In one embodiment, applications 100 and 101 are applications running on servers 108 and 109, respectively. Applications 100 and 101 have the ability to access (e.g., read and write to) file system 103 using a network file system protocol such as Network File System (NFS) or the Common Internet File System (CIFS) running over a network such as Ethernet.
In the context of the present example, file system 103 can be referred to as an “original” or “master” file system because it stores content (e.g., files) and corresponding metadata. File system 106 can be derived at least in part based on file system 103 and store information for carrying out searches with respect to the content in file system 103.
Server 119 includes a corresponding repository (e.g., storage media) to store and maintain file system 103. Similarly, server 112 includes a corresponding repository (e.g., storage media) to store and maintain file system 103.
In one embodiment, application 107 is a search application (such as, for example, the Google Desktop Search application from GoogleTM, or any other type of search or querying application) running on server 109 that accesses file system 106 (e.g., via server 112) for purposes of identifying one or more files in file system 103 that satisfies a search query. As will be discussed later in this specification, the user 110 controls the application 107 to search for files in file system 103 by providing search criteria.
File system 106 can be considered an “optimized-view” file system because, according to one embodiment, it includes a scaled back or transformed version of the information contained in file system 103 (e.g., the master file system). File system 106 enables efficient searching of information stored in the file system 103.
Initially, assuming that file system 106 has not yet been created or that file system 103 and file system 106 need to be synchronized with each other, view generator 105 completely scans all of file system 103 and generates corresponding file system 106. Creation of file system 106 depends at least in part on view configuration information 104. That is, according to one embodiment, view configuration information 104 specifies the types of information in file system 103 to replicate and/or include in file system 106. Thus, file system 106 can include at least a partial replication of the master file system 103, but scaled down as specified by the view configuration information 104.
In one embodiment, view configuration 104 includes the information as illustrated in FIG. 2. As shown, view configuration information 104 indicates multiple view options or parameters such as object type, filename, path, owner, author, age, size, type, content tags, data, etc. These different options (e.g., metadata tag options and specific content tag options) indicate the different types of metadata in file system 103 associated with each of one or more files in file system 103 that can be replicated and reproduced in file system 106. Markings (e.g., x-marks) in the column labeled “File System 106” of view configuration information 104 indicate what types of metadata and/or file data will be copied from the master file system 103 to the file system 106 for a given one or more file or directories (e.g., resources) to which the view configuration information 104 is applied.
The two options (e.g., “All data from original file” and “First 512 bytes from original file”) under “DATA” heading specify whether to copy an entire original file, or 512 bytes of the original file, etc. from file system 103 over to file system 103. Accordingly, view configuration information 104 can specify types of metadata as well as portions of content in file system 103 for copying over to file system 106. Thus, certain embodiments herein are directed towards applying view configuration information 104 (e.g., template information) to a respective file or directory in the file system 103 and replicating a portion of the respective file in the file system 103 for inclusion in the file system 106.
The view configuration information 104 can be applied to any resources such as a single file, a set of files, a directory resource, etc. Also, note that file management system 90 can include multiple different instances of view configuration information 104 that are applied to different files in file system 103 to produce file system 106. Accordingly, file system 106 can include a copy of a complete file and corresponding metadata for certain specified files, directory of files, etc. while file system 106 includes only certain specified types of metadata for other specified files, etc.
As mentioned, based on use of view configuration information 104 and file system 103, view generator function 105 generates file system 106. Note that the file system 106 can include a directory and filename structure that corresponds directly to the directory and filename structure of file system 103. For example, the file system 103 can include a hierarchical tree of directories, sub-directories, filenames, etc. for storing content such as multiple files. File system 106 can include a same or substantially similar hierarchical tree structure as file system 103 for storing replicated information.
When creating file system 106, the view generator function 105 can default to configuring the same security and access control settings in optimized file system 106 as the settings found in file system 103.
As mentioned above, view generator 105 creates the files and/or metadata information stored in file system 106 to include the text strings or tags which are marked with an “X” in the “File System 106” column of FIG. 2 for view configuration information 104 that will be applied to a particular file in the master file system 103.
For example, consider a file in file system 103 called “patent_application—001.doc”, which is stored in a directory or file path such as \corp\engineering. Based on examining the file system attributes (e.g., metadata information associated with “patent_application—001.doc”) in file system 103, view generator 105 determines “patent_application—001.doc” has a file size less than 1 MB, a last modify time that is greater than one month and less than 1 year ago, the file is owned by user John Smith, etc. When creating file system 106, the view generator 105 formats this information (of file system 103) into strings in accordance with the view configuration information 104 in FIG. 2 (assuming that the view configuration information 104 applies to “patent_application—001.doc”).
These data strings as specified by the view configuration information 104 are then written to the file “patent_application—001.doc” in file system 106. Since the view configuration information 104 in this example also specifies text strings to be searched in the original file, view generator 110 reads the contents of file “patent_application—001.doc” in file system 103 and searches for the strings “Company Confidential”, “Patent”, and “Competitor” as specified by specific content tags in view configuration information 104. In this example, assume that the view generator function 105 finds the first two strings (e.g., “Company Confidential”, “Patent”), but not the third string (“Competitor”). The view generator function 105 then writes this information in the format described in FIG. 2 to the file “patent_application—001.doc” in file system 106. An example of final data written to file system 106 for the example file “patent_application—001.doc” is shown in FIG. 3. Accordingly, the view generator function 105 according to embodiments herein can support operations of retrieving a given file from the master file system 103 and, based on a text string as specified in the template information (e.g., view configuration information 104), search for instances of the text string in the given file. In response to detecting an instance of the text string (e.g., the word “patent”) in the file, the view generator function 105 maintains the secondary repository of information to include an indication that the file includes at least one instance of the text string.
In one example embodiment as mentioned, at least a portion of file system 103 and file system 106 have a similar hierarchical tree structure for storing information. For example, assume that file system 103 includes a directory named “Sales Presentations” including respective files named “Presentation 1”, “Presentation 2”, and “Presentation 3.” When creating file system 106, view generator function 105 applies corresponding view configuration information 104 to the named resources (e.g., the directory named “Sales Presentations” as well as each of the respective files named “Presentation 1”, “Presentation 2”, and “Presentation 3”) to produce a respective file in the file system 106 for each resource. A file in the file system 106 can have an identical name as the corresponding file in the master file system 103 to which it is related. However, as discussed, the files (e.g., “Presentation 1”, “Presentation 2”, and “Presentation 3”) in file system 103 each include the original information. The files in the file system 106 include metadata associated with the corresponding file master file system 103. Thus, the file named “Presentation 1” in the master file system 103 can include original information while the file named “Presentation 1” in file system 106 can include the appropriate metadata information (e.g., similar to that shown in FIG. 3), the file named “Presentation 2” in the master file system 103 can include original information while the file named “Presentation 2” in file system 106 can include the appropriate metadata information (e.g., similar to that shown in FIG. 3), and so on.
One benefit of naming the metadata files in the file system 106 with the same names as original files in file system 103 is that results produced by search application 107 immediately have a corresponding file path to any files in file system 103 that satisfy a search based on which metadata information in file system 106 produces a match. For example, suppose that a search application (e.g., application 107) utilizes an index to identify that the “view” file as in FIG. 3 satisfies search criteria provided by a user. Results of a search can include a file name and path the “view” file as in FIG. 3. When a hierarchical tree in the file system 106 mirrors the hierarchical tree for storing information in file system 103, the file name and file path to the “view” file is the same file path and file name information that can be used in the master file system 103 to retrieve the associated original document.
As described herein, although resources such as directories, sub-directories, folders, etc. may not have a corresponding file in file system 106, the file system 106 can include a “view” file for storing metadata associated with the directory, sub-directory, etc., even though the directory or folder may not be a file. Accordingly, a directory or folder in file system 103 can have arbitrary data (e.g., metadata information and a corresponding name optimized for searching) associated with it in file system 106 just as has been previously described for files. Directories in a respective file system normally do not store arbitrary “contents” as do files. As will be discussed below, one embodiment herein includes associating a directory in file system 103 with both a directory and a view file in file system 106. The arbitrary data (e.g., metadata information) associated with a directory can then be stored as content in the file associated with the directory in file system 106.
More specifically, one embodiment herein includes maintaining a “view” file in file system 106 for a directory of file system 103. The view file in file system 106 can have a special name that provides an indication that the “view” file corresponds to a storage resource (e.g., a directory) in the file system 103 that is not a file for storing data as do “Presentation 1”, “Presentation 2”, and “Presentation 3”. For example, the directory name of an example directory in file system 103 is “Sales Presentations”. The corresponding view file information (e.g., file of metadata information) in file system 106 can be named “Sales Presentation—DIRVIEW—”. The text “DIRVIEW” (e.g., directory view) in this metadata file stored in file system 106 provides an indication that the corresponding resource in file system 103 is a directory instead of a file.
In this way, search application 107 can index any information that the view generator 105 stores as the contents of file “Sales Presentation—DIRVIEW—” and user can limit queries to directories by specifying the term OBJECTTYPE:DIR in a respective query. For example, a view file (e.g., including relevant metadata) associated with the “Sales Presentations” directory in file system 103 can include metadata information (e.g., OBJECTTYPE:DIR) indicating that the view file in file system 106 pertains to a directory in file system 103. For view files in file system 106 corresponding to files in file system 103, the view file information can specify OBJECTTYPE:FILE to specify that the corresponding resource in file system 103 pertaining to the view file is a file as opposed to a directory.
If the OBJECTTYPE is not specified then a corresponding search can be performed against both files and directories. If the OBJECTTYPE is specified in a search, then the corresponding search can be performed against the type of object (or objects) as specified by the search criteria.
In such an embodiment, file system 106 can now store information related to directory deletion and rename just as with files. This is important since the negative impact on an enterprise of accidental and inappropriate deliberate deletion and renaming of directories can be very high. Therefore, rapid and accurate diagnosis may be critical. Embodiments herein support such a function.
As another example, based on processing of the view configuration information 104 (e.g., template information), the view generator function 105 can identify selection of path information as a parameter associated with a given file in the primary repository to copy to the secondary repository. In other words, view configuration information 104 in FIG. 2 can indicate that metadata stored in file system 106 should include a path associated with a respective file. Accordingly, when creating the file system 106, the view generator function 105 replicates identified path information associated with the given file from the file system 103 for inclusion in the file system 106.
View generator function 105 can repeat the process of applying view configuration information 104 (or different versions of view configuration information) to each of multiple files in file system 103 to create file system 106.
As mentioned above, the DATA heading of view configuration information 104 of FIG. 2 specifies that the original data (i.e., user or application data) from this file (i.e., “patent_application—001.doc”) will not be written to (the optimized view in) file system 106. For example, there are no check-marks (e.g., Xs) in view configuration information 104 for entries under the heading DATA to copy data from a network original file of file system 103 to file system 106. Accordingly, the example information (e.g., metadata 310) in FIG. 3 for inclusion in file system 106 does not include any content (e.g., text strings) in the original file (e.g., “patent_application—001.doc”) other than strings “Company Confidential” and the word “patent.” Thus, the view configuration information 104 can be used as a filter for specifying what data in the file system 103 shall be copied over and included in file system 106.
Accordingly, embodiments herein include maintaining a first repository (e.g., file system 103) to include a first hierarchical tree structure for storing the multiple files and keeping track of corresponding metadata; maintaining a second repository (e.g., file system 106) to include a second hierarchical tree structure substantially similar to the first hierarchical tree structure; and utilizing the template information (e.g., view configuration information 104) to identify what if any portions of the multiple files and the corresponding metadata in the first hierarchical tree structure (e.g., file system 103) to copy to the second hierarchical tree structure (e.g., file system 106). In this way, file system 106 can provide a “view” into file system 103. In accordance with the view represented by file system 106, in lieu of including the data contents in the master file system 103, the file system 106 includes metadata represented as a configurable set of strings or “tags” as specified by the view configuration information 104. The type, format, or quantity of information that can be stored in file system 106 to provide a view as described herein need not be limited because the file management system 90 as described herein can support a wide range of views depending on settings as specified by the view configuration information 104, which can be optimized over time for a particular application.
Referring again to FIG. 1, according to one embodiment, application 107 can be a search application (e.g., a search engine application) that generates indexing information to contents of the files stored in file system 106 and/or corresponding information such as files stored in file system 103. In one embodiment, indexing is performed periodically based on algorithms defined within the search application. In similar fashion, the view generator 105 will periodically rescan the contents of file system 103 and then modify file system 106 to reflect any changes it discovers. Accordingly, file system 106 can be automatically synchronized with file system 103 over time.
User 110 (e.g., a client at a corresponding computer system) can communicate over a link such as a network with server 109. Server 109 enables the user 110 to access application 107 and perform queries against the generated index (e.g., file system 106 that provides an index to content or files in file system 103). Typically, the user 110 can access application 107 via a web browser in communication with application 107. One example of a web browser screen to carry out searches is Google Desktop Search as shown in FIG. 4.
According to one embodiment, application 107 includes a number of functional components. For example, application 107 can be a search application including a “crawler” function that is configured to read all the contents of a specified file system or web server (e.g., file system 106) that needs to be searched, an “index” function that efficiently establishes the identity of any files that satisfy a query from a user (the crawler is the data source for the index), and a “search” function that provides a query interface (e.g., a web page) to the user enabling the user to input search criteria and thereafter that uses a generated index to identify matches and reply to query requests.
One purpose of the index function is to optimize the speed and performance of finding relevant documents for a search query. For example, the index function of application 107 produces an index (prior to receiving any search requests) that enables quick searching of information in a database in accordance with the “view” information (e.g., metadata information) stored in file system 106.
Without implementing an index function to pre-create an index (as in one embodiment herein), using a “brute force” search method, a search engine (e.g., application 107) would have to scan every file on every query which could take an impractical amount of time and consume unacceptable amounts of storage and computing resources. For example, an index according to embodiments herein of one million files can often provide accurate search results within a matter of milliseconds, whereas a raw scan and “brute force” search applied to a file system storing one million files could take on the order of hours. The cost of creating an index to provide faster search results is additional storage required to store the index. In certain instances, it may take a considerable amount of time to update an index when there are changes to a corresponding file system such as file system 106. Thus, these factors must be weighed when making a decision whether to implement an index function or not.
The most common search engines index “text” in human-readable documents. They typically support queries based on the presence (or absence) of various words or combinations of words. For example, a user of a search engine could search for all files that contain the word “tornado”. Embodiments herein can greatly extend the applications of text-based search engines by “feeding” them alternative (and more optimized for their needs . . . ) forms of the original file system 103. These alternative forms can be easily defined, generated, and customized to meet varying needs without requiring any changes to existing file systems or search engine technologies.
By way of example, assume that a file system such as file system 106 contains a large number of documents used by an enterprise. A conventional approach would be to index every document in the file system. The alternative approach includes a technique of indexing an “optimized-view” (file system 106) of the original file system 103. The optimized view file system 106 can be defined to include the information most commonly used in searches. This can reduce the size of the index and increases its speed. For example, the index produced using the file system 106 can be much less complex and more useful than creating an index using master file system 103. For example, by representing a more structured view of an original file in file system 103 as a set of TAG:VALUE pairs (e.g., metadata information) stored in a secondary repository (e.g., file system 106) that is in turn indexed by an unmodified search engine, the customer (e.g., one or more users) gains the benefit of practical and fully-customized searches without changes to an existing infrastructure (e.g., file system 103). In other words, the search engine indexes the TAG:VALUE pairs in the file system 106 (e.g., secondary file system) as if the TAG:VALUE pairs were single words. Thus, a user can create a simple set of search criteria, which are easily executed by application 107 for producing useful results the user. In one embodiment, the application 107 can be accessed by a user 110 running on the same system (such is the case for Google Desktop Search which is considered a “personal” application). However, in alternative embodiments, application 107 can be executed on a computer system independent of a system on which the user is hosted as illustrated.
User 110 can construct a query (e.g., inquiry) using the search function 410 as shown in FIG. 4 using one or more text strings defined in FIG. 2. For example, based on input with respect to input data field 420, search function 110 in FIG. 4 illustrates a query generated by user 110 that instructs Google Desktop Search to return a list of all files in file system 106 which contain three strings: i) TYPE=word-doc, ii) SIZE<1 MB, and iii) OWNER=John Smith. The results returned by server 109 for this query are shown in FIG. 5.
As expected, the search results associated with the above search includes a link to “patent_application001.doc”, which in this example is the only file in this optimized view (e.g., in file system 106) that contains the three text strings as specified by search criteria input to data field 420 by clicking on and/or activating search button 425. If other files in the file system 106 had corresponding metadata that satisfied the search criteria, such files also would be included in the results illustrated in FIG. 5. Thus, screenshot 500 in FIG. 5 specifies search results 510 that satisfy the inputted search criteria. Note that the search results 510 can include pointers (e.g., references or links such as URLs, links, file paths, etc.) to information stored in file system 103 and/or file system 106. A respective user 110 can therefore submit a respective search and thereafter easily obtain files or documents satisfying the search.
The index generated from the “view” represented by file system 106 can easily support some operations that are otherwise very difficult to perform using the index based on just use of file system 103. For example, using a standard query interface (e.g., the search function 410 in FIG. 4), there are no options to perform this query on the index of file system 103 and the user 110 (or users as the case may be) would be forced to use a different application or perform the search manually. Using an “advanced search” option of Google Desktop Search (e.g., search function 410 in FIG. 4), the user 110 may be able to perform a query to return all files of type presentation (by using a filter such as a Powerpoint filter), but the remaining query criteria (size and owner) would have to be applied manually by examining the size and owner for each returned file. Embodiments herein solve this problem because (as mentioned above) the search function can specify size, owner, and other parameters in the search for finding the appropriate stored information.
In an Enterprise environment, extra manual steps of browsing through a list of search results can be very time consuming and have the practical effect of removing the option for the user to perform this type of query. This situation is very common. Many Enterprise search queries need, at least first, to perform a search against information (e.g., metadata) “related” to the contents (e.g., files) of the file system.
Beyond the benefits related to ease of performing queries, using an optimized view (e.g., file system 106) as described herein can greatly improve the speed and overhead of the indexing process. For a typical Enterprise including a mix of file sizes, file system 106 (the optimized view) can be about 1/1000 the size of file system 103 (the original file system). Accordingly, file system 106 need not consume an exorbitant amount of storage capacity and corresponding processing resources.
There is another benefit of using an optimized view as described herein. For example, such a technique can be used to strike a more flexible balance between information security and ease of information access. As described, the view configuration information 104 as illustrated in FIG. 2 can be used to create a view that has sufficient information to support many forms of useful searching in the Enterprise environment. In addition, this view and any query results can contain much less confidential and sensitive information than the original file system 106. This can help reduce security concerns related to indexes, which are currently getting increased attention.
Search applications for desktops are sometimes available as no cost downloads from companies such as GoogleTM, MicrosoftTM, and YahooTM. This availability, combined with the real need for a better solution to efficiently locate information, has motivated many Enterprise employees to index file systems containing sensitive Enterprise information on their portable computers. Unfortunately, portable computers can be stolen. This allows inappropriate parties to gain access to sensitive information.
One solution to this problem is to implement the embodiments herein to create views that contain low levels of sensitive information, but which when used in conjunction with a search application, help authorized users to find the information they need to efficiently perform their jobs. This disclosure includes an observation that the information that helps authorized users to efficiently find information is often metadata that by itself is not very sensitive in nature.
For example, an authorized user may need to be reminded of a filename that they were working on last week. A simple query that returns just the names of all the files modified by the specific user over the last week would greatly help in this case. This query does not require any of the actual data to be indexed. This same approach could be used to allow “safe” web server access to perform searches even when the web server supports a lower-level of access control security compared to network file systems.
Note that any or all of the data (e.g., file system 103 and file system 106) maintained by respective server 119 and server 112 can be maintained in a “classical” file system type of environment or a database type environment (in which the database appears as a file system rendered on the fly in view of the applications). Thus, either or both of file system 103 and file system 106 can be stored in a database as records of information as well.
FIG. 6 is an example diagram of a file management system 690 including a log file functionality according to embodiments herein. As shown, file management system 690 includes server 207 for executing application 200, server 208 for executing logging agent 201, server 209 for managing file system 202, server 210 for executing log file system 203, server 211 for executing view generator function 204, server 212 for managing file system 205, and server 213 for executing application 206.
In general, in addition to the components as discussed above for FIG. 1, FIG. 6 includes log agent 201 executing on server 208 and a log file system 203 (e.g., a logging function) executing on server 210. Application 200 initiates changes to contents of file system 202. Logging agent 201 manages the changes to file system 202 and notifies log file system 203 of any changes. Log file system 203 logs the changes.
Based on application of view configuration information 214 (in a similar way as discussed above for FIG. 1), view generator function 204 updates file system 205 in accordance with the changes as specified by the log file system 203. Server 213 can support application 206 such as a search engine enabling user 110 to submit search criteria that are applied to file system 205 for purposes of identifying files in file system 202 having certain characteristics. Master file system 202 can include all of the information typically associated with a standard file system, while file system 205 can provide an optimized view that supports efficient searching as discussed above. Accordingly, one embodiment herein includes logging occurrence of file operations associated with the multiple files stored in file system 202 (in a primary repository), and initiating modification of the file system 205 (in a secondary repository) in accordance with the logged file operations such that search inquiries applied to the file system 205 yield corresponding search results reflecting a current state of the file system 202 including application of the file operations to the multiple files in the file system 202. In other words, the logging agent 201 can identify changes to file system 202. The view generator function 204 can initiate updating file system 205 based on the changes as specified by log information in log file system 203.
More particularly, file management system 690 in FIG. 6 utilizes a logging agent 201 to provide a log of file system operations. Logged operations specify how the content in file system 202 has been modified over time. As will be discussed, the log operations can be used by the view generator function 204 to update a “view” file system 205 in a more efficient way than by initiating a complete re-scan of the master file system 202 to produce file system 205. Additionally, the log operations according to embodiments herein can include a wide variety of additional detailed information that can be used to produce corresponding metadata for storage in file system 205.
While FIG. 6 illustrates a logging server as a logging agent 201 running on dedicated server 208, the logging agent functionality as shown in FIG. 6 can be implemented in one or more locations such as in application 200, on server 207, in a file system or network stack, in a network switch like an Acopia ARX, on file server 209, etc. An example of such a network switch (e.g., an Acopia ARX switch) is discussed in co-pending US Patent Application entitled “METHOD AND APPARATUS FOR ADAPTIVE SERVICES NETWORKING” filed Jan. 13, 2004, having U.S. Ser. No. 10/756,189. This utility Patent Application claims the benefit of the filing date of the following earlier filed U.S. Provisional Patent Applications: 1) “METHODS AND APPARATUS FOR ADAPTIVE SERVICES NETWORKING” filed Jan. 13, 2003 having U.S. Ser. No. 60/439,763; and 2) “METHODS AND APPARATUS FOR INSERTING A FILE SERVER LOAD BALANCING DEVICE INTO A NETWORK” filed Aug. 28, 2003 having U.S. Ser. No. 60/498,475. The entire teachings and contents of these referenced Applications are hereby incorporated herein by reference in their entirety.
In one embodiment, the logging agent functionality is provided by the logging service (acting as logging agent 201) on server 208 (e.g., a Network Service Module) in an Acopia ARX switch. This type of implementation provides high-performance and high reliability. A representative flow diagram (e.g., flowchart 900) associated with logging agent 201 is shown in FIG. 9.
Logging agent 201 can be configured to write a record (or records) to the appropriate log file in log file system 203 in accordance with file system operations (e.g., reads read operation writes) applied to file system 202. A record in log file system 203 can contain detailed information about each file operation performed with respect to file system 202.
A suitable record format 725 for storing information (e.g., via records) in log file system 203 is shown in FIG. 7. The format 725 of the protocol specific portion of the record is defined by the appropriate network file system specification. In the case of NFS version 3, the document entitled “RFC 1813—NFS Version 3 Protocol Specification” defines the format of all file system operations. As an example, FIG. 8 contains the detailed description of an NFS Create remote procedure call 825 extracted from this specification.
Similar to the embodiments as discussed above with respect to FIG. 1, during initialization (e.g., creation of file system 205), view generator 204 scans file system 202 in its entirety and creates a corresponding file system 205 as defined by view configuration 214. After initialization, the view generator function 204 periodically reads the log files (e.g., records) stored in log file system 203.
FIG. 10 is a diagram of a flowchart 1000 executed by view generator function 204 for decoding log files in log file system 203 and updating file system 205 according to embodiments herein.
As previously mentioned, log-based updating of file system 205 has two benefits. First, log-based updating of file system 205 saves the overhead and latency of performing a complete scan of file system 202 again each time there is a change to the master file system 202. Second, log-based updating of file system 205 provides the raw information that can be used to generate almost any kind of file system statistic. These statistics can then be represented as strings within the files stored in file system 205. In as similar vein as the view configuration information 104 in FIG. 2, FIGS. 11 and 12 include respective view configuration information 1120 and view configuration information 1220 defining a variety of tags to be generated (for inclusion in file system 205) based on processing of the records in the log file system 203.
Note that there may be some situations in which the files and directories within a view file system (e.g., file system 205) do not have a one-to-one relationship with the original file system 202. Consider the case in which the delete or rename tags described in FIG. 12 are included in the view configuration. A delete or rename file operation will cause the removal of a file from the original file system 602. If the view file system 205 retains the information associated with the deleted file for some amount of time (for example 6 months) after they are deleted or renamed in the original file system 202, then these tags can be written to files in the view file system 205, which correspond to the deleted or renamed files in the original file system 202. In this way, applications and users can perform queries such as “show me all of files deleted by user John Smith over the last month” (USERNAME:John_Smith and DELETED:Lessthan1Month).
In one embodiment, the view file system 205 could assist a user 110 in a file recovery operation by including a “restore” tag that contains the location(s) in an archive or backup system of a backup copy of the deleted file. FIG. 13 shows an example of metadata information 1325 stored in a view file system 205 for a deleted file. As mentioned, retaining this information (e.g., metadata information 1325) even after a corresponding file (e.g., patent_application—001tmp.doc) in file system 202 has been deleted can be useful for certain types of searches requesting a view of operations applied to a file that currently is or was stored in the master file system 202. Any of this information can be used for searching purposes. For example, a user 110 can provide search criteria with files in file system 202 having specific corresponding metadata that matches or satisfies the search criteria.
Accordingly, embodiments herein can include logging occurrence of file operations applied to one or more of the multiple files stored in file system 202 (e.g., a primary repository); initiating storage of modification information as searchable parameters in the file system 205 (e.g., a secondary repository) in accordance with the logged file operations stored in log file system 203; and enabling application of searches to the storage modification information in the file system 205 to search for files in file system 202 based on operations applied to the multiple files in file system 202.
FIG. 14 is a diagram of file management system 1400 according to embodiments herein. This embodiment is similar to the file management systems as previously discussed, but this embodiment adds an incremental update path between view generator function 224 and file system 225. This update path can greatly reduce the time delay between a change in file system 222 and the reflection of that change at application 226. If application 226 is a search application as described in the embodiment of FIG. 1, then the benefit of including the update path(s) is that the index is updated in almost real-time (typically in the order of seconds) compared with hours for approaches that require full-scanning of the original file system with a large number of files. An additional benefit is that the file operation load on file system 222 and corresponding file server 229 related to supporting file system 225 drops to zero, except for the initialization phase that occurs when the view is first established. As mentioned, file system 225 can be created based on an initial full scan of file system 222 and application of corresponding view configuration information 214. Servers 227 including application 220, 228, 229, 230 including log file system 223, 231, 232, and 233 shown in FIG. 14 are same as servers 207, 208, 209, 210, 211, 212, and 213, respectively, shown in FIG. 6.
FIG. 15 includes a sample program 1510 (e.g., software code such as that provided by GoogleTM) that can be used to implement an update transaction between view generator 224 and application 226. In one embodiment, application 226 is a Google SearchTM application running on a Google SearchTM appliance. A similar program could be written by one skilled in the art to support other applications that natively support incremental updates.
A variation of this embodiment supports a direct update path from logging agent 221 to application 226 or to file system 225. This embodiment could support a synchronous update to application 226, which can be useful for compliance and data protection related applications. This variation may require some functionality associated with view generator function 224 be moved to the logging agent 221. The moved functionality permits the logging agent 221 to convert a log record directly into an update operation for sending directly to the application 226 or file system 225. Accordingly, logging agent 221 can provide one or more fast update paths so that file system 222 and file system 225 are automatically synchronized in real-time or near real-time. Accordingly, embodiments herein include enabling a logging function (e.g., logging agent 221) that keeps track of changes to the primary repository (e.g., file system 221) to convert stored records (e.g., records of file system operations performed on file system 222) into update operations for modifying the secondary repository (e.g., file system 225 optimized for searching) such that the file system 222 and the file system 225 are automatically synchronized with each other in substantially real-time.
FIG. 16 is a diagram of an example composite file 1600 according to embodiments herein. Composite files 1600 can be used to scale search applications (e.g., application 226) to much higher file counts. In this embodiment, the files presented in the view (e.g., file system 225) optimized for a search application are not mapped in a one-to-one manner to the files in the original file system 222. Contents of file system 225 are instead presented as composite files 1600 in which the tags corresponding to the multiple files are stored in a single file of the view file system (e.g., file system 225).
As an example, assume that a search application (e.g., application 226) has a limit of 1 million files. This search application is presented in a file system view (e.g., file system 225) in which each file contains tag-based descriptions (a “tag group”) for 100 of the original files in file system 222. These composite files 1600 can store the entire tag description for a file system 222 with 100M (e.g., 100 million) files in 1M (e.g., 1 million) composite files 1600 of file system 225. In this environment, the unmodified search application (e.g., application 226) is now able to search across the tag descriptions of 100×1M or 100M files. Thus, the limitation has been removed. Accordingly, one embodiment herein includes producing file system 225 at the server 232 (e.g., a repository) to include one or more composite files 1600, each of which includes groupings of metadata information associated with multiple corresponding files in the file system 222 (e.g., a repository); receiving a search request from a source such as user 110; and utilizing the one or more composite files 1600 in the file system 225 at server 232 to identify multiple files in the master file system 222 that satisfy the search request.
FIG. 17 is a diagram of a management system 1700 that scales the file count capability of a search application according to embodiments herein. User 265 connects to search agent 260 using an interface such as a web browser. Search agent 260 presents the user 260 with a simple query screen similar to that illustrated in FIG. 4. User 265 can perform queries by using the tags defined in the view configuration information used to derive file system 262 in a manner as previously discussed. In response to a query request from user 265, search agent 260 forwards the query to search application 261. Search application 261 responds to the query by returning any matches it finds to content of the files stored in file system 262. In other words, the search application 261 responds to a search inquiry by identifying files in file system 262 (e.g., the optimized view) that satisfy the search parameters in the search inquiry.
File system 262 can be derived from file system 264 and include the composite file approach as illustrated in FIG. 16. Due to the composite nature of the files in file system 262, the query results returned by search application 261 must be processed prior to presentation to user 265. For example, search agent 260 processes each match in the response by first fetching the entire contents of a composite file in file system 262 that matches. This composite file is then searched tag group by tag group for a match against the query criteria. On a match of a tag group, a response record, which includes the name of the file as stored in the FILENAME tag is generated (this corresponds to the name of the file in file system 264). When all matches have been found and response records generated or the number of matches exceeds the maximum number of match results that will be returned on a query, then the records are assembled into a single response that is then returned to user 265. Accordingly, embodiments herein include receiving a search request; fetching a composite file 1600; comparing search criteria in the search request to each group of metadata in the composite file 1600; and for each respective group of metadata in the composite file 1600 that matches the search criteria, including a corresponding file name of a corresponding file in the file system 264 for inclusion in a reply to the search request.
It is entirely possible that a composite file that matches against the query will not yield any matches at the tag group (individual file level). For example, consider a query consisting of “SIZE:<1 MB and TYPE:word-doc”. It is entirely possible that a tag group within a given composite file would match on SIZE:<1 MB and another tag group would match on TYPE:word-doc but no single tag group would contain both desired tags. This condition will result in a match from the search application. Search agent 260 handles this condition by treating the lack of any matches on its tag-group check for a given composite file to be an acceptable result.
User 265 can use the embodiment illustrated in FIG. 17 to implement a two-tiered search (or search agent 260 could be modified to hide the existence of the two tiers from the user). To perform a two-tier search, user 265 would first perform a fast search based on the contents of file system 262. Then these results would be used to either query the complete content index maintained by application 263 of the original file system 264 or to perform the second search directly against the contents of the specified files in file system 264. The performance of the latter approach can be reasonable if the first search results represent a modest number of files that actually must be searched in file system 264. Accordingly, embodiments herein enable a multi-tiered search capability including: i) a first search applied to the file system 262 to identify a group of files in the file system 264; and ii) a second search that utilizes results of the first search to apply to the file system 264 and identify the files match both search criteria.
Another option is to index a view, which consists of the tags and all the content from the original file system 264 (this is illustrated as DATA option of FIG. 2). This index would be larger than the index for the original file system 264 but it would have the ability to perform any combination of tag and content match queries.
FIG. 18 illustrates a system 1800 that adds the ability of an application to modify (write) the contents of a file in the view file system 336 (stored on server 356) as a way to add tags beyond those generated by the view generator according to embodiments herein. These tags act as flexible extended metadata at the granularity of a file and can be used to influence the behavior of other applications. In FIG. 18, application 330 (stored on server 350), logging agent 331 (stored on server 351), original file system 332 (stored on server 352), log file system 333 (stored on server 353), and view generator 334 (stored on server 354) behave as previously described for FIG. 14. Application 338 (stored on server 358) reads from view file system 336 and, if needed, original file system 332. If application 338 finds a condition of interest, it can generate a tag identifying this condition and write it into the appropriate file or files in view file system 336. The write by application 338 is logged by logging agent 337 (stored on server 357) to log file system 339 (stored on server 359). In turn, view generator 340 (stored on server 360) monitors log file 339 and when it detects there has been a modify-type operation to view file system 336, it notifies application 341 of this modification. Application 341 (stored on server 361) can now take action based on this modification. This action can include an interaction with application 338. View configuration information 335 is configured same as view configuration information 214 of FIG. 14, details of which will not be repeated here.
As an example, application 336 is an advanced content classification application that can classify a file based on a sophisticated analysis of the contents of the file. This application runs various algorithms to determine if a file contains highly-sensitive information. Based on its on-going analysis, application 338 can continually add and remove tags from files in view file system 336. In turn application 341, which in this example is a file placement application contained within an Acopia ARX switch, can take the actions related to these tags. In the case that a file in file system 103 contains highly-sensitive information and has been tagged “highly-sensitive” in view file system 336, application 341 can transparently migrate the file to a storage unit that stores all data in encrypted form. Application 341 can then optionally write a tag (“STORAGE_TYPE:encrypted”) to file system 336 that indicates that the corresponding file is now stored on encrypted storage. In turn, these tags can be read by application 338 to determine when a file classified as “highly-sensitive” has been successfully migrated to encrypted storage. Accordingly, sources other than view generator function 334 can provide metadata information for storage in view file system 336.
Another advantage of this approach is that metadata contained within existing applications such as an Enterprise Content Management (ECM) application can be exported into a view file system. As an example, in FIG. 15, application 338 is an ECM application (example: Documentum from EMM corporation) and it maintains large amounts of metadata related to files it manages within internal databases. Application 338 can export this metadata in the form of tags written to view file system 336. In this way, the metadata from application 338 is now available for general use by other applications. Accordingly, this is yet another example of how sources other than a view generator function can provide metadata information for storage in view file system 336.
FIG. 19 is a block diagram illustrating an example computer system 380 (e.g., a server as discussed above) for executing the functionality and other processes according to embodiments herein. Computer system 380 may be a computerized device such as a personal computer, workstation, portable computing device, console, network terminal, processing device, etc.
As shown, computer system 380 of the present example includes an interconnect 311 that couples a memory system 312, a processor 313, an I/O interface 314, and a communications interface 315. I/O interface 314 enables computer system 380 to receive input from peripheral devices 316 and display screen 317 (if computer system 380 is so equipped). Communications interface 315 of computer system 310 enables computer system 380 to communicate over network 390 or other connection to transmit information to and receive information from different resources such as other servers.
As shown, memory system 312 is encoded with view generator application 105-1 supporting creation and management of file system 106. View generator application 105-1 can be embodied as software code such as data and/or logic instructions (e.g., code stored in the memory or on another computer readable medium such as a disk) that support functionality according to different embodiments described herein.
During operation of view generator application 105-1, processor 313 accesses memory system 312 via the interconnect 311 in order to launch, run, execute, interpret or otherwise perform the logic instructions of the view generator application 105-1. Execution of the view generator application 105-1 produces processing functionality in view generator process 105-2. In other words, the view generator process 105-2 represents one or more portions of the view generator application 105-1 (or the entire application) performing within or upon the processor 313 in the computer system 380.
It should be noted that view generator process 105-2 executed in computer system 380 (e.g., server 111, server 211, server 229, server 354, etc.) can be represented by either one or both of the view generator application 105-1 and/or the view generator process 105-2. For purposes of the above discussion and different embodiments herein, general reference has been made to view generator function 105 as performing or supporting the various steps and functional operations as previously discussed.
As mentioned, in addition to the view generator process 105-2, embodiments herein include the view generator application 105-1 itself (i.e., the un-executed or non-performing logic instructions and/or data). The view generator application 105-1 may be stored on a computer readable medium such as a floppy disk, hard disk, or optical medium. The view generator application 105-1 may also be stored in a memory type system such as in firmware, read only memory (ROM), or, as in this example, as executable code within the memory system 312 (e.g., within Random Access Memory or RAM). In addition to these embodiments, it should also be noted that other embodiments herein include the execution of view generator application 105-1 in processor 313 as the view generator process 105-2. Thus, those skilled in the art will understand that the computer system 380 may include other processes and/or software and hardware components, such as an operating system that controls allocation and use of hardware resources.
As discussed above, techniques herein are well suited for use in applications such as those that support management of stored information. However, it should be noted that configurations herein are not limited to such use and thus configurations herein and deviations thereof are well suited for use in other environments as well.
While this invention has been particularly shown and described with references to preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the present application as defined by the appended claims. Such variations are covered by the scope of this present disclosure. As such, the foregoing description of embodiments of the present application is not intended to be limiting. Rather, any limitations to the invention are presented in the following claims. Note that the different embodiments disclosed herein can be combined or utilized individually with respect to each other.

## Claims

1. A method comprising:
maintaining a primary repository to store multiple files and metadata information associated with the multiple files;
receiving template information specifying types of the metadata information associated with the multiple files stored in the primary repository; and
applying the template information to the metadata information in the primary repository to produce a secondary repository of information comprising one or more metadata files with a subset of the metadata information, the metadata files having filenames comprising at least filenames of the corresponding multiple files in the primary repository; and
receiving a search inquiry, utilizing a hierarchical file system in the secondary repository of information to perform a search, and identifying at least one of the multiple files in a hierarchical file system of the primary repository that satisfies the search inquiry based at least in part on at least a partial match of the filename of at least one corresponding metadata file.

2. A method as in claim 1, wherein applying the template information to the metadata information in the primary repository includes replicating the metadata information as specified by the template information for inclusion in the secondary repository.

3. A method as in claim 1 further comprising:
in response to receiving search criteria, utilizing the secondary repository of information to produce a reference to a corresponding file in the primary repository that has associated metadata satisfying the search criteria.

4. A method as in claim 1 further comprising:
maintaining the primary repository to include a first hierarchical tree structure for storing the multiple files and keeping track of corresponding metadata associated with the multiple files;
maintaining the secondary repository of information to include a second hierarchical tree structure based upon the first hierarchical tree structure; and
utilizing the template information to identify what, if any, portion of the multiple files and the corresponding metadata in the first hierarchical tree structure to include in the second hierarchical tree structure.

5. A method as in claim 1 further comprising:
based on application of the template information to a respective file in the primary repository, replicating a portion of the respective file in the primary repository for inclusion in the secondary repository.

6. A method as in claim 1, wherein applying the template information to the metadata information in the primary repository includes:
retrieving a given file from a file system in the primary repository;
based on a text string as specified in the template information, searching for instances of the text string in the given file; and
in response to detecting an instance of the text string in the file, maintaining the secondary repository of information to include an indication that the file includes at least one instance of the text string.

7. A method as in claim 1 further comprising:
for a given file of the multiple files in the primary repository, creating a corresponding view file of metadata information associated with the given file based on metadata information in the primary repository associated with the given file; and
storing the corresponding view file in the secondary repository, the corresponding view file having same filename and filepath information as the given file in the first repository.

8. A method as in claim 1, wherein applying the template information includes:
based on processing of the template information, identifying selection of path information as a parameter associated with a given file in the primary repository to copy to the secondary repository; and
replicating identified path information associated with the given file from the primary repository to the secondary repository.

9. A method as in claim 1 further comprising:
logging occurrence of file operations associated with the multiple files stored in a file system of the primary repository; and
initiating modification of the secondary repository in accordance with the logged file operations such that search inquiries applied to the secondary repository yield corresponding search results reflecting a current state of the primary repository including application of the file operations to the multiple files in the primary repository.

10. A method as in claim 1 further comprising:
logging occurrence of file operations applied to the multiple files stored in a file system of the primary repository;
initiating storage of modification information as searchable parameters in the secondary repository in accordance with the file operations; and
activating application of searches to the storage modification information in the second repository to search for files in the primary repository based on operations applied to the multiple files in the primary repository.

11. A method as in claim 1 further comprising:
activating a logging function that keeps track of changes to the primary repository to convert stored records into update operations for modifying the secondary repository such that the primary repository and the secondary repository are automatically synchronized with each other in real-time.

12. A method as in claim 1 further comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information associated with multiple corresponding files in the primary repository;
receiving a search request; and
utilizing the composite file in the file system of the secondary repository to identify multiple files in the primary repository that satisfy the search request.

13. A method as in claim 1 further comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information, each group of metadata information being associated with a corresponding file in the primary repository;
receiving a search request;
fetching the composite file;
comparing search criteria in the search request to each group of metadata in the composite file; and
for each respective group of metadata that matches the search criteria, including a corresponding file name of a corresponding file in the primary repository for inclusion in a reply to the search request.

14. A method as in claim 1 further comprising:
activating a multi-tiered search including: i) a first search applied to the secondary repository to identify a group of files in the primary repository; and ii) a second search that utilizes results of the first search to apply to the primary repository and identify a subset of the identified group of files.

15. An apparatus comprising:
at least one processor; and
memory coupled to the at least one processor which is configured to execute program instructions stored in the memory comprising:
maintaining a primary repository to store multiple files and metadata information associated with the multiple files;
receiving template information specifying types of the metadata information associated with the multiple files stored in the primary repository;
applying the template information to the metadata information in the primary repository to produce a secondary repository of information comprising one or more metadata files with a subset of the metadata information, the metadata files having filenames comprising at least filenames of the corresponding multiple files in the primary repository; and
receiving a search inquiry, utilizing a hierarchical file system in the secondary repository of information to perform a search, and identifying at least one of the multiple files in a hierarchical file system of the primary repository that satisfies the search inquiry based at least in part on at least a partial match of the filename of at least one corresponding metadata file.

16. An apparatus as in claim 15, wherein applying the template information to the metadata information in the primary repository includes replicating metadata information as specified by the template information for inclusion in the secondary repository.

17. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
in response to receiving search criteria, utilizing the secondary repository of information to produce a reference to a corresponding file in the primary repository that has associated metadata satisfying the search criteria.

18. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
maintaining the primary repository to include a first hierarchical tree structure for storing the multiple files and keeping track of corresponding metadata associated with the multiple files;
maintaining the secondary repository of information to include a second hierarchical tree structure based upon the first hierarchical tree structure; and
utilizing the template information to identify what, if any, portion of the multiple files and the corresponding metadata in the first hierarchical tree structure to include in the second hierarchical tree structure.

19. An apparatus as in claim 15, wherein applying the template information to the metadata information in the primary repository includes:
retrieving a given file from a file system in the primary repository;
based on a text string as specified in the template information, searching for instances of the text string in the given file; and
in response to detecting an instance of the text string in the file, maintaining the secondary repository of information to include an indication that the file includes at least one instance of the text string.

20. An apparatus as in claim 15, wherein applying the template information includes:
based on processing of the template information, identifying selection of path information as a parameter associated with a given file in the primary repository to copy to the secondary repository; and
replicating identified path information associated with the given file from the primary repository to the secondary repository.

21. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
logging occurrence of file operations associated with the multiple files stored in a file system of the primary repository; and
initiating modification of the secondary repository in accordance with the logged file operations such that search inquiries applied to the secondary repository yield corresponding search results reflecting a current state of the primary repository including application of the file operations to the multiple files in the primary repository.

22. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
logging occurrence of file operations applied to the multiple files stored in a file system of the primary repository;
initiating storage of modification information as searchable parameters in the secondary repository in accordance with the file operations; and
enabling application of searches to the storage modification information in the second repository to search for files in primary repository based on operations applied to the multiple files in the primary repository.

23. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
enabling a logging function that keeps track of changes to the primary repository to convert stored records into update operations for modifying the secondary repository such that the primary repository and the secondary repository are automatically synchronized with each other in real-time.

24. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information associated with multiple corresponding files in the primary repository;
receiving a search request; and
utilizing the composite file in the file system of the secondary repository to identify multiple files in the primary repository that satisfy the search request.

25. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information, each group of metadata information being associated with a corresponding file in the primary repository;
receiving a search request;
fetching the composite file;
comparing search criteria in the search request to each group of metadata in the composite file; and
for each respective group of metadata that matches the search criteria, including a corresponding file name of a corresponding file in the primary repository for inclusion in a reply to the search request.

26. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising, based on application of the template information to a respective file in the primary repository, replicating a portion of the respective file in the primary repository for inclusion in the secondary repository.

27. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising:
for a given file of the multiple files in the primary repository, creating a corresponding view file of metadata information associated with the given file based on metadata information in the primary repository associated with the given file; and
storing the corresponding view file in the secondary repository, the corresponding view file having same filename and filepath information as the given file in the first repository.

28. An apparatus as in claim 15 wherein the at least one processor is further configured to execute programmed instructions stored in the memory further comprising activating a multi-tiered search including: i) a first search applied to the secondary repository to identify a group of files in the primary repository; and ii) a second search that utilizes results of the first search to apply to the primary repository and identify a subset of the identified group of files.

29. A non-transitory computer readable medium having stored thereon instructions comprising machine executable code which when executed by at least one processor, causes the processor to perform steps comprising:
maintaining a primary repository to store multiple files and metadata information associated with the multiple files;
receiving template information specifying types of the metadata information associated with the multiple files stored in the primary repository;
applying the template information to the metadata information in the primary repository to produce a secondary repository of information comprising one or more metadata files with a subset of the metadata information, the metadata files having filenames comprising at least filenames of the corresponding multiple files in the primary repository; and
receiving a search inquiry, utilizing a hierarchical file system in the secondary repository of information to perform a search, and identifying at least one of the multiple files in a hierarchical file system of the primary repository that satisfies the search inquiry based at least in part on at least a partial match of the filename of at least one corresponding metadata file.

30. A medium as in claim 29, wherein applying the template information to the metadata information in the primary repository includes replicating the metadata information as specified by the template information for inclusion in the secondary repository.

31. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising, in response to receiving search criteria, utilizing the secondary repository of information to produce a reference to a corresponding file in the primary repository that has associated metadata satisfying the search criteria.

32. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
maintaining the primary repository to include a first hierarchical tree structure for storing the multiple files and keeping track of corresponding metadata associated with the multiple files;
maintaining the secondary repository of information to include a second hierarchical tree structure based upon the first hierarchical tree structure; and
utilizing the template information to identify what, if any, portion of the multiple files and the corresponding metadata in the first hierarchical tree structure to include in the second hierarchical tree structure.

33. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising, based on application of the template information to a respective file in the primary repository, replicating a portion of the respective file in the primary repository for inclusion in the secondary repository.

34. A medium as set forth in claim 29, wherein applying the template information to the metadata information in the primary repository includes:
retrieving a given file from a file system in the primary repository;
based on a text string as specified in the template information, searching for instances of the text string in the given file; and
in response to detecting an instance of the text string in the file, maintaining the secondary repository of information to include an indication that the file includes at least one instance of the text string.

35. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
for a given file of the multiple files in the primary repository, creating a corresponding view file of metadata information associated with the given file based on metadata information in the primary repository associated with the given file; and
storing the corresponding view file in the secondary repository, the corresponding view file having same filename and filepath information as the given file in the first repository.

36. A medium as set forth in claim 29, wherein applying the template information includes:
based on processing of the template information, identifying selection of path information as a parameter associated with a given file in the primary repository to copy to the secondary repository; and
replicating identified path information associated with the given file from the primary repository to the secondary repository.

37. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
logging occurrence of file operations associated with the multiple files stored in a file system of the primary repository; and
initiating modification of the secondary repository in accordance with the logged file operations such that search inquiries applied to the secondary repository yield corresponding search results reflecting a current state of the primary repository including application of the file operations to the multiple files in the primary repository.

38. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
logging occurrence of file operations applied to the multiple files stored in a file system of the primary repository;
initiating storage of modification information as searchable parameters in the secondary repository in accordance with the file operations; and
activating application of searches to the storage modification information in the second repository to search for files in the primary repository based on operations applied to the multiple files in the primary repository.

39. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising activating a logging function that keeps track of changes to the primary repository to convert stored records into update operations for modifying the secondary repository such that the primary repository and the secondary repository are automatically synchronized with each other in real-time.

40. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information associated with multiple corresponding files in the primary repository;
receiving a search request; and
utilizing the composite file in the file system of the secondary repository to identify multiple files in the primary repository that satisfy the search request.

41. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising:
producing a file system in the secondary repository to include a composite file including groups of metadata information, each group of metadata information being associated with a corresponding file in the primary repository;
receiving a search request;
fetching the composite file;
comparing search criteria in the search request to each group of metadata in the composite file; and
for each respective group of metadata that matches the search criteria, including a corresponding file name of a corresponding file in the primary repository for inclusion in a reply to the search request.

42. A medium as set forth in claim 29 further having stored thereon instructions that when executed by the processor causes the process to perform steps comprising activating a multi-tiered search including: i) a first search applied to the secondary repository to identify a group of files in the primary repository; and ii) a second search that utilizes results of the first search to apply to the primary repository and identify a subset of the identified group of files.