|Numéro de publication||US8380932 B1|
|Type de publication||Octroi|
|Numéro de demande||US 12/212,414|
|Date de publication||19 févr. 2013|
|Date de dépôt||17 sept. 2008|
|Date de priorité||13 déc. 2002|
|État de paiement des frais||Payé|
|Numéro de publication||12212414, 212414, US 8380932 B1, US 8380932B1, US-B1-8380932, US8380932 B1, US8380932B1|
|Inventeurs||John H. Martin, Mark R. Scheevel|
|Cessionnaire d'origine||Open Text S.A.|
|Exporter la citation||BiBTeX, EndNote, RefMan|
|Citations de brevets (58), Citations hors brevets (30), Référencé par (18), Classifications (5), Événements juridiques (10)|
|Liens externes: USPTO, Cession USPTO, Espacenet|
This application is a continuation in part of U.S. patent application Ser. No. 11/825,909, entitled “Method And System For Cache Management” by Lee Shepstone, Conleth O'Connell, Mark R. Scheevel, N. Isaac Rajkumar, Jamshid Afshar, Puhong You, Brett J. Larsen, and David Dean Caldwell, filed Jul. 10, 2007 (now U.S. Pat. No. 7,818,506); which is a continuation in part of U.S. patent application Ser. No. 10/733,742 (now U.S. Pat. No. 7,360,025), entitled “Method and System for Automatic Cache Management” by Conleth O'Connell, Mark R. Scheevel, and N. Isaac Rajkumar, filed Dec. 11, 2003; which claims the benefit of U.S. Provisional Patent Application No. 60/433,408, entitled “Extensible Framework for Caching and Configurable Caching Parameters” by N. Isaac Rajkumar, Conleth O'Connell, Jamshid Afshar, Puhong You, Brett J. Larsen and David Dean Caldwell, filed Dec. 13, 2002. This application is related to U.S. patent application Ser. No. 10/733,798 (now U.S. Pat. No. 7,188,216), entitled “Method and System for an Extensible Caching Framework” by N. Isaac Rajkumar, Puhong You, David Dean Caldwell, Brett J. Larsen, Jamshid Afshar and Conleth O'Connell; filed Dec. 11, 2003. This application is related to U.S. patent application Ser. No. 11/444,023, entitled “System And Method For The Dynamic Provisioning Of Static Content”, by Rajkumar et al.; filed on May 31, 2006. This application is related to U.S. patent application Ser. No. 11/444,020, entitled “System And Method For The Provisioning Of Dynamically Generated Content,” by Rajkumar et al. filed on May 31, 2006 (now U.S. Pat. No. 7,860,820). All applications cited within this paragraph are fully incorporated herein by reference.
Embodiments of the disclosure relate generally to managing page caches and more particularly to systems and methods of invalidating and regenerating cached pages based on invalidation events.
Communication of data over computer networks, particularly the Internet, has become an important, if not essential, way for many organizations and individuals to disseminate information. The Internet is a global network connecting millions of computers using a client-server architecture in which any computer connected to the Internet can potentially receive data from and send data to any other computer connected to the Internet. The Internet provides a variety of methods by which to communicate data, one of the most ubiquitous of which is the World Wide Web. Other methods for communicating data over the Internet include e-mail, usenet newsgroups, telnet and FTP.
The World Wide Web is a system of Internet servers, typically called “web servers”, that support the documents and applications present on the World Wide Web. Documents, known as web pages, may be transferred across the Internet according to the Hypertext Transfer Protocol (“HTTP”) while applications may be run by a Java virtual machine present in an internet browser. Web pages are often organized into web sites that represent a site or location on the world wide web. The web pages within a web site can link to one or more web pages, files, or applications at the same web site or at other web sites. A user can access web pages using a browser program and can “click on” links in the web pages being viewed to access other web pages.
Each time the user clicks on a link (or types an address into a browser program), the browser program generates a request and communicates it to a web server hosting web pages or applications associated with the web site. The web server retrieves the requested web page or application from an application server or Java server and returns it to the browser program. Web pages and applications can provide a variety of content, including text, graphics, interactive gaming and audio and video content.
Because web pages and associated applications can display content and receive information from users, web sites have become popular for enabling commercial transactions. As web sites become more important to commerce, businesses are increasingly interested in quickly providing responses to user's requests. One way of accelerating responses to requests on a web site is to cache the web pages or applications delivered to the requesting user in order to allow faster access time to this content when it is next requested.
Current caching methods, however, typically provide very limited functionality. This functionality may be particularly limited when it comes to dealing with changes in content. When an identical request is presented content may be served from the cache, even though this content may have been updated at the application server in the intervening time span; or content responsive to the request must once again be generated and cached, delaying the response to the request.
With the proliferation of information on the Internet, it is becoming increasingly difficult to prepare and deliver content to end users in an efficient and timely manner. Current content delivery systems employ various content publishing techniques. Typically, most web sites are produced by in-sequence publishing actions. For example, a set of web pages can be generated by an application server and made available to a web server for appropriate actions. In other words, to implement a web site, a set of web pages may be produced at an application layer and published at a presentation layer.
In response to an end user request, the web server may serve one or more web pages to the end user. As repeatedly serving frequently requested web pages can consume resources, dynamically generated web pages can be cached to quickly service user requests and conserve processing and network resources. Thus, when an end user elects to “refresh” previously delivered content (e.g., by clicking a “Refresh” button on a browser application's menu), the same content may be retrieved from a cache and again delivered to that end user.
All of the web pages implementing a web site can be updated as needed or reproduced at some regular interval to incorporate changes in the content. However, in conventional content delivery systems, all of the web pages implementing the web site may have to be reproduced. Moreover, changes made to the content may only be taken into account at the intervals at which the web pages are reproduced. Thus, web pages delivered to an end user may, for a period of time, contain stale content. In addition, reproducing web pages for each and every web site affected by certain changes may require a long period of time.
Another content publishing technique involves portal applications or standard Java® service or Server Page (JSP) applications. These applications typically have dynamic scripting capability that can work in tandem with hypertext markup language (HTML) code to separate the logic of a page from its static elements (e.g., the actual design layout and display of the page). The extracted portion of the page can then be used to make dynamic database queries and assemble pages on-the-fly accordingly. However, the logic and the content underlying the pages assembled on-the-fly can be modified after the pages are delivered, thereby allowing stale content to remain in circulation.
Embodiments of the present disclosure provide systems and methods for regenerating cached pages that eliminate, or at least substantially reduce, the shortcomings of previously available systems and methods for regenerating cached pages.
Systems and methods for invalidating and regenerating pages are provided by various embodiments. In one embodiment, a method can include detecting content changes in a content database including various objects. The method can include causing an invalidation generator to generate an invalidation event based on the modification to a set of one or more content objects and communicating the invalidation event to a dependency manager. A cache manager can be notified that one or more pages in a cache might be invalidated based on the invalidation event.
In one embodiment, a method can include receiving a page invalidation notice and sending a page regeneration request to a page generator. The method can include regenerating the cached page. The method can include forwarding the regenerated page to the cache manager and replacing the cached page with the regenerated page.
In one embodiment, a method can include invalidating a cached page based on a content modification and regenerating pages which might depend on the modified content. In some embodiments, the method can include determining whether a cached page which can be dependent on various sets of objects and can be stored in the page cache is affected by the modification of the set of one or more objects stored in the content database. The dependencies between the cached page and the set of objects can be stored in a dependency database accessible by the dependency manager. In some embodiments, the dependencies can be discovered during regeneration of the cached page. The dependencies can include a reference to the cached page and a reference to a set of object in some embodiments.
One embodiment disclosed herein may provide a computer readable storage medium storing instructions for implementing methods of invalidating and regenerating cached pages as described above. One embodiment of a system for regenerating a cached page may comprise a processor and a computer readable storage medium accessible by the processor and storing instructions executable by the processor to perform methods of invalidating and regenerating cached pages as described above.
Embodiments disclosed herein can provide many advantages. For example, regenerating cached pages can reduce the amount of stale data in the cache. When stale data happens to be in the cache, embodiments disclosed herein can reduce the time during which such stale data resides in the cache. Furthermore, overlapping invalidation events may allow invalidated pages to remain in the cache. Embodiments disclosed herein can detect overlapping modifications and can avoid caching pages which may have become stale while being regenerated. In embodiments disclosed herein, pages can be invalidated based on events. In some embodiments, invalidated pages can be regenerated. In some embodiments, invalidated pages can be discarded. By reducing the amount of stale data in the cache, embodiments disclosed herein can facilitate the fast and efficient delivery of correct and timely content.
These, and other, aspects will be better appreciated and understood when considered in conjunction with the following description and the accompanying drawings. The following description, while indicating various embodiments and numerous specific details thereof, is given by way of illustration and not of limitation. Many substitutions, modifications, additions, or rearrangements may be made within the scope of the disclosure, and the disclosure includes all such substitutions, modifications, additions, or rearrangements.
A more complete understanding of the disclosure and the advantages thereof may be acquired by referring to the following disclosure, taken in conjunction with the accompanying drawings in which like reference numbers generally indicate like features.
Various embodiments of the disclosure are illustrated in the FIGURES, like numerals being generally used to refer to like and corresponding parts of the various drawings. Embodiments of the disclosure provide systems and methods for regenerating cached pages.
Before discussing specific embodiments, an embodiment of a hardware architecture for implementing certain embodiments is described herein. One embodiment can include a computer communicatively coupled to a network (the Internet in some embodiments). As is known to those skilled in the art, the computer can include a central processing unit (“CPU”), at least one read-only memory (“ROM”), at least one random access memory (“RAM”), at least one hard drive (“HD”), and one or more input/output (“I/O”) device(s). The I/O devices can include a keyboard, monitor, printer, electronic pointing device (such as a mouse, trackball, stylist, etc.), or the like. In various embodiments, the computer has access to at least one database over the network.
ROM, RAM, and HD are computer memories for storing computer-executable instructions executable by the CPU. Within this disclosure, the term “computer-readable medium” is not limited to ROM, RAM, and HD and can include any type of data storage medium that can be read by a processor. In some embodiments, a computer-readable medium may refer to a data cartridge, a data backup magnetic tape, a floppy diskette, a flash memory drive, an optical data storage drive, a CD-ROM, ROM, RAM, HD, or the like.
The functionalities and processes described herein can be implemented in suitable computer-executable instructions. The computer-executable instructions may be stored as software code components or modules on one or more computer readable storage media (such as non-volatile memories, volatile memories, DASD arrays, magnetic tapes, floppy diskettes, hard drives, optical storage devices, etc. or any other appropriate computer-readable storage medium or data storage device). In one embodiment, the computer-executable instructions may include lines of complied C++, Java, HTML, or any other programming or scripting code.
Additionally, the functions of the disclosed embodiments may be implemented on one computer or shared/distributed among two or more computers in or across a network. Communications between computers implementing embodiments can be accomplished using any electronic, optical, radio frequency signals, or other suitable methods and tools of communication in compliance with known network protocols.
As used herein, the terms “comprises,” “comprising,” “includes,” “including,” “has,” “having” or any other variation thereof, are intended to cover a non-exclusive inclusion. For example, a process, article, or apparatus that comprises a list of elements is not necessarily limited only those elements but may include other elements not expressly listed or inherent to such process, article, or apparatus. Further, unless expressly stated to the contrary, “or” refers to an inclusive or and not to an exclusive or. For example, a condition A or B is satisfied by any one of the following: A is true (or present) and B is false (or not present), A is false (or not present) and B is true (or present), and both A and B are true (or present).
Additionally, any examples or illustrations given herein are not to be regarded in any way as restrictions on, limits to, or express definitions of, any term or terms with which they are utilized. Instead, these examples or illustrations are to be regarded as being described with respect to one particular embodiment and as illustrative only. Those of ordinary skill in the art will appreciate that any term or terms with which these examples or illustrations are utilized will encompass other embodiments which may or may not be given therewith or elsewhere in the specification and all such embodiments are intended to be included within the scope of that term or terms. Language designating such nonlimiting examples and illustrations includes, but is not limited to: “for example”, “for instance”, “e.g.”, “in one embodiment”.
A few terms are defined or clarified to aid in understanding the descriptions that follow. A network includes an interconnected set of server and client computers over a publicly available medium (e.g., the Internet) or over an internal (company-owned) system. A user at a client computer may gain access to the network using a network access provider. An internet Service Provider (“ISP”) is a common type of network access provider.
Within this disclosure, term “portal” generally refers to a gateway that is or can be a starting site, a home site, or an anchor site for networked end users visiting the World Wide Web (WWW or web). Examples of portals include www.yahoo.com, www.cnet.com, www.microsoft.com, and www.aol.com. A portal is a kind of web site with a rich navigation structure of internal links within the same site and external links to other sites. In some cases, a company may provide one or more portals connecting the company's intranet to the web. Currently, most portals adopt a style of categorizing content with a text-intensive, fast loading web page. Services provided by portals or portal sites typically include a directory of web sites or links, a search facility to search for other sites, news, weather, email, stock quotes, maps, and so on.
A portal site may comprise portlets or portal pages through which a plurality of channels and sub-channels of content can be presented to end users. Large scale portal sites capable of handling a high volume of content are typically built with a few “page templates” that can be reused to display content. For example, in response to an end user request, a portal page may be assembled on-the-fly based on a page template. In this manner, content displayed on the portal site can remain relatively up-to-date and not all pages of the portal site must be reproduced to limit the overall amount of stale content in the portal site.
Web sites and portal sites, particularly large scale portal sites, are generally produced and managed at the server side, transparent to end users. While content delivery systems employing JSP or portal applications offer many advantages, there is no automated process to coordinate update activities in the backend. For example, update activities made by, and at, a content management system may not be automatically propagated to a content delivery system. This may result in stale content remaining in caches in the content delivery system. Therefore, there is a need for new systems and methods for regenerating cached pages.
Within this discussion, the term “complex record” refers to a single logical entity that may comprise more than one row in more than one table within a database. The term “software component” refers to at least a portion of a computer program (i.e., a software application). Examples include a content delivery software component, a content management software component, or the like. Different software components may reside in the same computer program or in different computer programs on the same computer or different computers.
Before discussing embodiments, an exemplary hardware architecture for use in conjunction with embodiments is described. While the it may useful to an understanding of embodiments to describe embodiments in conjunction with such an exemplary architecture it will be understood that embodiments may also be implemented in conjunction with a wide variety of other architectures. In
For example, if the requested web page includes dynamic content, the web server 10 may initiate a script, using, for example, the common gateway interface (“CGI”) mechanism, to send data (e.g. a request or portions thereof) to an application server 20 to generate the dynamic content. Application server 20 can generate dynamic HTML (or other types of) content according to a programming language such as Java, C or PERL and return the contents to web server 10. Web server 10 can, in turn, communicate the content back to the client computer as the requested web page.
In some cases, content may be assembled from other content chosen based on a request initiated by a user of a site. This may be better explained with reference to
Caching content in cache 25 may, however, be somewhat problematic. More particularly, content may be added (e.g. to a data store associated with application server 20), where this content may be pertinent, or otherwise related, to content in cache 25. For example, suppose content responsive to a user request includes content generated by a component operable to generate content comprising headlines corresponding to the five most recent news articles (e.g. in a data store). Suppose further that in response to the user request this content is generated by the component using the five most recent news articles and stored in cache 25.
Now suppose that a news article is added (e.g. to the data store). Here, the content stored in cache 25 has been rendered stale by virtue of the newly added article. In other words, if the component which originally generated the content were now invoked the content generated would be different than the cached content (e.g. it would include the headline from the newly added news article). Thus, any subsequent responses to user requests which utilize the previously cached content (e.g. requests which reference a template associated with the component which generated the cached content) may comprise the stale cached content until such a point as the cached content is flushed or regenerated.
Similarly, cached content within cache 25 may also be rendered stale through changes to content already present when the cached content was generated. Continuing with the above example, suppose content responsive to a user request includes content generated by a component operable to generate content comprising headlines corresponding to the five most recent news articles (e.g. in a data store). Suppose further that in response to the user request this content is generated by the component using the five most recent news articles and stored in cache 25. Now suppose that the headline of one of the five most recent news article is altered. Here, the content stored in cache 25 has been rendered stale by virtue of the altered article. Again, if the component which originally generated the content were now invoked the content generated would be different than the previously cached content (e.g. it would include the headline corresponding to the altered news article).
As can be seen from the above examples, there may be a period of time where stale content may be served to a user from the cache. As it is desired to communicate current information or content to users, it may be desirable to substantially minimize or otherwise reduce this time period.
To that end among others, attention is now directed to systems and methods for managing cached content. More particularly, embodiments may allow cached content to be updated (e.g. regenerated or replaced) based on newly added or changed content. Specifically, embodiments may allow cached content to be regenerated, replaced or updated based on newly added, or changed, content associated with the cached content such that cached content is updated substantially immediately when pertinent new content is added or content from which the cached content was generated is altered. By updating the cached content substantially immediately following an addition or alteration of content at least a twofold benefit may be achieved in the performance of a caching system or an associated site. Namely, the benefits of caching (e.g. speed) may be realized in addition to the benefits of serving substantially current content from the cache.
Embodiments of these systems and methods may facilitate the updating of cached content by associating metadata with cached content. In particular, this metadata may include a set of rule sensitivities associated with the generation of the cached content. These rule sensitivities, in turn, may allow a cache manager to dynamically update this cached content based upon conditions other than a request for similar content, including the addition of new content associated with the cached content or alterations or updates to content used to generate the cached content. In particular, these rule sensitivities may be used to locate or otherwise identify cached content pertinent to newly added content such that the cached content may be updated.
Furthermore, in some embodiments, the updating of located or identified cached content may be accomplished using the metadata stored in association with the cached content where the metadata includes metadata associated with the generation of the cached content. Embodiments of these systems and methods may facilitate the storing of metadata associated with cached content by using a generalized extensible architecture that allows evaluation of the parameters associated with the generation of the cached content such as sensitivities associated with a component or a wide variety of other parameters including those associated with cookies, form data, session data, request, browser capabilities, etc.
This metadata may comprise almost any data obtained in conjunction with the generation of the cached content, including rule sensitivities or content identifiers as discussed above. Additionally, the metadata may include request metadata obtained in conjunction with the request itself. This request metadata may pertain to the assembly of content which interests the user, and may consist of data pertaining to the individual aspects and parameters of the request, including parameters associated with a template which may be used to generate content responsive to the request. For example, the request may contain a Universal Resource Locator (URL), originating locale, a query string, or perhaps a user-agent string indicating the type of browser initiating the request. This metadata may be used by a cache manger to regenerate an original request in order to refresh the content residing in cache.
Metadata may also be obtained from the template used to assemble content responsive to a request. This template metadata may contain information on aspects of a request to which a particular piece of content may be sensitive, and whether a particular piece of content should be cached.
In one embodiment, a cache manager may be registered with an application manager which informs the cache manager when content has been updated or new content has been added. Based upon this notification and metadata associated with the cached content, the cache manager may identify cached content pertaining to the new or updated content. Using the metadata stored in association with the identified cached content a cache manager may regenerate a request associated with the cached content such that the cached content may be updated. Updating the cache may be done in the background without receiving a new request from a user, allowing content in the cache to be kept current and drastically improving the performance and response time of a web site.
This application manager may, in turn, be part of or in communication with a content deployment agent coupled to a content management system. The deployment agent may receive updated content, and the application manager may take notice when content has been updated or added in conjunction with the deployment agent. The application manager may also be responsible for the assembly of content to be delivered by an application server in response to a request from a user.
An extensible caching framework may be present on web server 10 to evaluate incoming requests or locate cached content responsive to the incoming request based on the parameters contained in the request. In particular, this extensible caching framework may provide one or more component sensitivities to be stored in conjunction with cached content such that cached content pertaining to newly added or altered content may be identified. This extensible caching framework may also formulate a signature to be utilized in retrieving this content from cache when a request for the same content is received by web server 10 and provides metadata to be stored in conjunction with the content in order to facilitate regeneration of the request which originally resulted in delivery or generation of the cached content.
Moving now to
When a module 202, 204, 206, 208 is registered with the framework, the module 202, 204, 206, 208 may initialize and pass to the framework a set of configuration variables, these configuration variables may include interface method 210 to be used between the framework and module 202. More specifically, this may include variables of an incoming request to be passed by framework 200 to module 202, the template metadata of the content requested and desired by module 202, and the format in which information is to be returned by module 202 to framework 200. This registration data may also include registering configuration variables used by the module 202, and specific routines used by the module 202 for request mapping. During operation of framework 200, when web server 10 receives a request, modules 202, 204, 206, 208 executing on web server 10 may each evaluate portions of the incoming request with respect to the parameter to which the module 202, 204, 206, 208 pertains and pass their respective evaluations to framework 200. These evaluations may include metadata regarding a parameter of a request, whether module 202, 204, 206, 208 believes the request should be served from cache 25 or passed along to application server 20, or a string value which may be used for locating responsive content in cache 25, for caching any content generated from application server 20 based on the request, or for assembling a signature to be associated with any content generated from application server 20.
Examples of caching parameters that may be evaluated by these modules include query string variables in the request, cookies in the request, the HTTP header in the request, form variables in the HTTP POST request, locale detected from the request, or a custom defined parameter. It will be readily apparent to those of ordinary skill in the art that a wide variety of parameters may be identified in requests and utilized in the caching of various pieces of content. Additionally, it will be apparent that because of the variety of these parameters the implementation of each module 202, 204, 206, 208 may vary greatly, and that the important concept is that modules may be added and removed from framework 200, and framework 200 will continue to utilize a set of available modules 202, 204, 206, 208 in the evaluation of incoming requests and the caching of the corresponding generated content.
The evaluation of these individual parameters allows content delivered in response to a request to be tailored more accurately to the specifics of an incoming request. For example, in some cases there may be many versions of a particular piece of content, one that employs Java, one that employs frames, and one that employs Active X. If content employing Java is delivered to a browser which utilizes Active X the content may be incorrectly displayed.
The data generated by modules 202, 204, 206, 208 may, in turn, be utilized in conjunction with cached content to regenerate cached content based upon added or altered content pertinent to the cache content. This ability may be explained in more detail with reference to
If responsive content is found it may be returned, (e.g. used to assemble content responsive to the request) at step 420. If, however, responsive content for a component is not located in the cache the method may further comprise generating responsive content using the component at step 410 and determining rule sensitivities or content identifiers at steps 412 and 414, respectively. This generated content may then be cached at step 416 and the rule sensitivities or content identifiers stored in such a manner that they are associated with the cached content to which they correspond at step 418.
Turning now to
In one embodiment, this action may flush the located cached content such that the next time a request for the same or similar content is received new content will be generated and stored in the cache. Alternatively, the request which resulted in that cached content may be regenerated (e.g. using metadata associated with the cached content) such that the component which generated the cached content may be invoked to generate new content, and this newly generated content used to replace the located cached content. It will be apparent after reading the above that other embodiments may take almost any variety of actions with respect to the located cached content, and that these actions are within the scope of the disclosure.
Note, as well, that not all of the activities described in the process flow diagrams are required, that an element within a specific activity may not be required, and that further activities may be performed in addition to those illustrated. Additionally, the order in which each of the activities are listed is not necessarily the order in which they are performed. After reading this specification, a person of ordinary skill in the art will be capable of determining which activities and orderings best suit any particular objective of an embodiment.
Moving now to
To illustrate more clearly with respect to the embodiment depicted, when an incoming request 612 is received by web server 10 request 612 is evaluated by caching framework 200 and its associated modules 202, 204, 206, 208 as described above. To elaborate in more detail, when a request comes in from a client computer this request usually contains a URL which references content which resides on application server 20. This piece of content may be assembled utilizing various associated components and returned to a client computer based upon specifics contained in the request. Consequently, a template may be formed which contains metadata regarding aspects of a request which may pertain to assembling the specifics and subparts of a particular piece of content, as discussed above. Thus, templates corresponding to content (which includes an application server such as a JSP (Java Service Pages), etc.), which are part of a web site may be registered with the extensible caching framework where a template comprises metadata pertinent to content to be generated utilizing, or in conjunction with, that template.
Thus, after a request 612 is received by web server 10 this request may be associated with a template by extensible caching framework 200 residing on web server 10. For example, a request issued from a client computer usually contains a URL which may refer to a specific piece of content residing on application server 20, along with associated data pertaining to how a user on the client computer would like the requested content assembled. Consequently, extensible caching framework 200 can identify content that is to be assembled in accordance with this request by comparing the URL of an incoming request with registered templates associated with application server 20. Framework 200 may then associate the template corresponding to the requested content with the incoming request
This identified template, in turn, may correspond to a set of components, as described above. Extensible caching framework 200 may parse or otherwise obtain information relating to the components associated with the template corresponding to the incoming request and pass this information, along with associated template metadata or other data associated with request or template, to modules 202, 204, 206, 208.
In turn, each module 202, 204, 206, 208, 210, 212 may evaluate the parameters or metadata to which it pertains. Modules 202, 204, 206, 208 invoked for this evaluation process may return several pieces of data to caching framework 200. Data which may be returned by a module 202, 204, 206, 208 may be request or template metadata which is to be stored in conjunction with cached content in order to facilitate regeneration of the request which resulted in an associated piece of cached content.
It may also be determined if requested content associated with one or more of the components of the identified template is in cache 25. If requested content associated with a component corresponding to the template is not contained in cache 25 the request 612 (or portions thereof) is passed on to application server 20, where responsive content will be generated by the components associated with the template.
When a component is invoked to generate content in response to the request 612, a set of rule sensitivities and a set of content identifiers may be also be generated based on the content used to generate content responsive to the request. This generated content along with the corresponding set of rule sensitivities and content identifiers may then be passed to cache manager 620 or web server 10.
More specifically, when request 612 is passed to application server 20, component 670 may be selected by application server 20 to generate content responsive to the request 612. This component 670 may comprise a rule 672 which is configured to select content from data store 660 based on values for a set of criteria (e.g. type of the content, category of content, time of creation, author, etc.). For example a rule may select content where the Type=News in chronological order, with a maximum number of 10 or content, where the Type=News in chronological order, with a maximum number of 5, etc. The values and corresponding criteria associated with a particular rule are known as the rule sensitivities for that rule. In other words, for a rule which selects content where the Type=News in chronological order, with a maximum number of 10 the rule sensitivities for that rule may be Type=News (or just News), or the rule sensitivities may be Type=News, Order=Time, Number=10, for a rule which selects content where Type=News AND Category=Sports AND Sport=Basketball in chronological order, with a maximum Publish date of 3 days ago the rule sensitivities may be Type=News, Cat=Sports, Sport=Basketball and PubDate=Today−3, etc. Thus, rules sensitivities may be any set or subset of the values or criteria corresponding to a rule where the criteria may comprise almost any property which may be associated with selection of content including category, navigational aspects, time periods or other properties or attributes.
Rule 672 may be executed or otherwise implemented by rule execution engine 680 resulting in the selection of content from data sore 660. Once rule 672 has been used to select content from data store 660, the selected content may be further processed by component 670 to generate content 632 corresponding to the request. This generated content 632 may then be sent to web server 10 to assemble into content responsive to request 612. Additionally, generated content 632 may be sent to cache manager 620 from application server 20 along with the rule sensitivities 644 corresponding to rule 672 of component 670 used to generate the content 632. Furthermore, the content selected by execution of rule 672 may correspond to a set of content identifiers, where a unique content identifier may be associated with each piece of content stored in data store 660. These content identifiers 646 corresponding to content selected by rule 672 in conjunction with the generation of content 632 may also be sent to cache manager 620 in conjunction with content 632 and rule sensitivities 644.
Thus, when the generated content 632 is subsequently stored in cache 25, the cached content 634 (e.g. corresponding to the generated content 632) may be associated with a corresponding set of rule sensitivities 644 and content identifiers 646. Additionally, cached content 634 may be associated with metadata 638 pertaining to the template corresponding to cached content 634, or metadata 436 corresponding to the original request 612 (as discussed above). In one embodiment, cache manager 620 comprises metadata repository 640, where each entry in metadata repository 640 corresponds with an entry in cache 25. Thus, data associated with an entry in cache 25 such as content sensitivities, content identifiers, template metadata, request metadata, etc. may be stored in conjunction with an entry of metadata repository 640 and associated with a corresponding entry in cache 25 (for example, an entry in cache 25 and a corresponding entry in metadata repository 640 may be accessed using an identical signature, hash value, etc.) Thus, data associated with an entry in cache 25 may be passed from caching framework 200 or application server 20 to cache manager 620 for storage in conjunction with content generated in response to a request. Here, entry in cache 25 comprising content 634 corresponds to an entry in metadata repository 640 comprising rule sensitivities 644, content identifiers 646, metadata 638 pertaining to a template and metadata 436 corresponding to the original request 612.
At some point subsequent, content may be added to application server 20 (e.g. data store 660 associated with application server 20). This new content may be pertinent to content in cache 25, as discussed above. Thus, it may be desirable to update cache 25 with content generated based upon the content newly added to application server 20 in order that the most up to date content may be served from cache 25 in response to another request similar to request 612. Embodiments content 634 in cache 25 to be updated with current content without receiving a new request for this content. This may be accomplished by replacing previously cached content 634 with new content generated by a component (e.g. component 670) of application manager 20 in response to a regenerated request, where the regenerated request was initiated based upon added content.
More specifically, in one embodiment, cache manager 620 may be informed that content has been added (e.g. to data store 660, or another data store or location associated with application manager 20 or web server 10). In one particular embodiment this is done through an event. When an application or content (collectively referred to as content, herein) is added in conjunction with application server 20 this content is registered with application manager 630. In turn, application manager 630 may assemble values for a set of criteria associated with the newly added content. This set of criteria may comprise properties or metadata corresponding to the newly added content (e.g. type of the content, category of content, time of creation, author, etc.)
Application manager 630 may propagate the values for the set of criteria associated with the newly added content to cache manager 620 through a communication with the cache manager 620 (e.g. an event). Communication between application manager 630 and cache manager 620 may be accomplished, for example, through the use of Java Messaging Service (JMS), Hyper Text Transfer Protocol (HTTP), Service Oriented Architecture Protocol (SOAP) or eXtensible Markup Language (XML).
When cache manager 620 receives an event, the values for the criteria associated with the event may be utilized to search cache 25 to locate any content pertinent to the event (and thus pertinent to the newly added content corresponding to the event). In one embodiments, cache manager 620 may identify content in cache 25 pertinent to the event by comparing the values for the criteria associated with the event to rules sensitivities in the metadata repository 640 associated with the entries in cache 25. More specifically, for each of the values for the criteria of the event a query may be formed using the value for that criterion such that metadata repository 640 may be queried according to the value for that criterion (e.g. entries in metadata repository 640 may be obtained where the rules sensitivities in metadata repository 640 comprises a value corresponding to the value of the query). Additionally, queries which utilize values for multiple criteria associated with the event may also be used to query metadata repository 640. In one embodiment, cache manager 620 will recursively expand the content into all known rules sensitivities that would match this content had the rule sensitivities been executed as part of a query, performing a “what if” analysis. Thus, by locating entries in metadata repository 640 responsive to these queries, the associated entries in cache 25 which are pertinent to the newly added content may be identified.
As may be imagined values for a whole host of criteria may be associated with newly added content or stored in metadata repository 640 in conjunction with cached content. Thus, it may be desirable to perform the query (e.g. between values for the incoming event and values for rules sensitivities stored in association with cached content) efficiently. To improve efficiency of this query process, therefore, in one embodiment one or more queries may be recursively generated (and possibly concatenated) for each combination of values for the criteria of the event. This query generation may generate a query for a value for one of the criteria where values for all the other criteria are NULL (e.g. the query is performed without respect to the other criteria), and then additionally recursively building a query which adds values corresponding to each of the criteria with an AND operation. Depending on the number and type of criteria, the generation of queries corresponding with an event may result in a single query with grouped sub queries joined by OR functions, or it may generate multiple queries or it may optimize queries using database functions or an IN clause where supported.
It will be noted from a close review of the above description that similar techniques may be utilized in order to update or otherwise manage a cache based upon altered content. For example, content in data store 660 may be altered, where this altered content is pertinent to content in cache 25, as discussed above. Thus, it may be desirable to update cache 25 with content generated based upon this altered content. In this case a notification from application manager 630 to cache 630 may contain the content identifier of the content which was altered. This content identifier may be used to identify content in cache 25 pertinent to the altered content (e.g. generated based upon the content before the alterations took place) by comparing the content identifier of the notification with the content identifiers stored in metadata repository 640 which correspond to entries in cache 25.
After content in cache pertinent to the notification (e.g. cache entries pertinent to newly added or altered content), action may then be taken with respect to the identified cache entries. For example, the identified cache entries may then be flushed from cache 25. Alternatively, once cache manager 620 has identified cached content (e.g. content 634) that is pertinent to newly added or altered content, cache manager 620 may update this content in cache 25. This may be done by regenerating the request that resulted in content 632 being placed in cache 25.
In one embodiment, using request metadata 636, template metadata 638 or any other data in metadata repository 640 associated with the identified cached content, cache manager 620 can regenerate the request which caused application server 620 to generate cached content. Cache manager 620 may regenerate this request and pass it to application manager 20. Application manager 20, in turn, may utilize the request to invoke the component 670 which originally generated cached content 634 to generate content 652 (which may be generated using the newly added content) responsive to this regenerated request and return this newly generated content 652 to cache manager 620. Cache manager 620 can then replace the original content 632 with newly generated content 652 responsive to the regenerated request. In this manner, content in the cache 25 may be kept substantially current with content on application server 20.
Using these various cache management techniques content can be kept up to date in cache 25 without receiving a new request. Consequently, the next time similar a request 614 is received, content 652 responsive to this request 614 may be served from cache 25 as opposed to application server 20 generating responsive content 652 in response to the request. Serving responsive content 652 from cache 25 allows a web site to more quickly respond to an incoming request and reduces the strain on application server 20.
Within each of CDS 140 and CMS 160, a plurality of computers (not shown) may be interconnected to each other over internal network 115 or a combination of internal and external networks. For simplification, a single system is shown for each of CDS 140 and CMS 160. Other systems (e.g., page generator, application server, etc.) may be part of CDS 140, CMS 160, or additional systems that are bi-directionally coupled to the internal network 115.
A plurality of other client computers 120 may be bi-directionally coupled to external network 111, and a plurality of actor computers 80 may be coupled to internal network 115. Actor computers 80 may include personal computers or workstations for individuals that use internal network 115. These individuals may include content developers, editors, content reviewers, webmasters, information technology specialists, and the like. Many other alternative configurations are possible and known to skilled artisans.
Client computer 120 can include central processing unit (“CPU”) 122, read-only memory (“ROM”) 124, random access memory (“RAM”) 126, hard drive (“HD”) or storage memory 128, and input/output device(s) (“I/O”) 129. I/O 129 can include a keyboard, monitor, printer, electronic pointing device (e.g., mouse, trackball, etc.), or the like. Client computer 120 can include a desktop computer, a laptop computer, a personal digital assistant, a cellular phone, or nearly other device capable of communicating over a network. Actor computer 180 may be similar to client computer 120 and can comprise CPU 182, ROM 184, RAM 186, HD 188, and I/O 189.
CDS 140 can include a server computer comprising CPU 142, ROM 144, RAM 146, HD 148, and I/O 149, and CMS 160 can include a server computer comprising CPU 162, ROM 164, RAM 166, HD 168, and I/O 169. CDS 140 or CMS 160 may have one or more of a content delivery software component, a page generator software component, the content management software component, an applications software component, and the like.
Each of the computers in
Each of computers 120, 140, 160, and 180 is an example of a data processing system. ROM 124, 144, 164, and 184; RAM 126, 146, 166, and 186; HD 128, 148, 168, and 188; and databases 113, 117, and 119 can include media that can be read by CPU 122, 142, 162, or 182. Therefore, each of these types of memories includes a data processing system readable medium. These memories may be internal or external to computers 120, 140, 160, or 180.
Portions of the methods described herein may be implemented in suitable software code that may reside within ROM 124, 144, 164, or 184, RAM 126, 146, 166, or 186, or HD 128, 148, 168, or 188. In addition to those types of memories, the instructions in an embodiment may be contained on a data storage device with a different data processing system readable storage medium, such as a hard disk.
With reference now to
When a request for content is received from user device 152, request handler/cache reader 153 can determine whether page cache 170 contains the requested content. When page cache 170 contains the requested content, request handler/cache reader 153 can serve that content to user telecommunications device 152. When page cache 170 does not contain the requested content, request handler/cache reader 153 can forward the request to capture filter 155. Capture filter 155 can set up cache control information associated with the requested content and pass such information and control to page generator 154. Page generator 154 can generate the requested content (in conjunction with some content source(s) in some embodiments) and return the requested content to capture filter 155. Page generator 154 can annotate the cache control information with additional information regarding the requested content and return the annotated cache control information with the requested content. Capture filter 155 can forward the requested content and annotated cache control information to request handler/cache reader 153. Request handler/cache reader 153 can then serve the requested content to user device 152.
In the meantime, capture filter 155 can parse the annotated cache control information for information pertaining to the dependency of certain objects within the requested content on other objects within the requested content (or associated therewith). Capture filter 155 can forward the requested content and associated dependency and cache control information to dependency manager 176. Dependency manager 176 can forward the requested content to cache writer 172 for storage in page cache 170. Dependency manager 176 can store the dependency information and cache control information for subsequent use. Invalidation generator 174 will notify dependency manager 176 that one or more objects on which pages in page cache 170 depend have been modified. Dependency manager 176 then uses the dependency information that it stored earlier to identify pages in page cache 170 that should be invalidated.
With reference now to
In some embodiments, system 300 can serve pages to portals operating on the Internet or an enterprise network. In some embodiments, system 300 can include a separate content management system 324, a separate content delivery system 322, and a separate invalidation generator 314 in communication with content management system 324 and content delivery system 322. In some embodiments, content management system 324 can include content manager 306, and content database 308. In some embodiments, content delivery system 322 can include request handler 303, page generator 304, capture filter 305, page cache 310, cache manager 312, dependency manager 316, and dependency database 318.
In some embodiments, pages 340 can be static pages containing dynamically provisioned content. U.S. patent application Ser. No. 11/444,023, entitled “SYSTEM AND METHOD FOR THE DYNAMIC PROVISIONING OF STATIC CONTENT”, filed on May 31, 2006, by Rajkumar et al. discloses systems and methods for the dynamic provisioning of static content and is incorporated herein as if set forth in full. In some embodiments, pages 340 can be dynamic pages containing dynamically generated content. U.S. patent application Ser. No. 11/444,020, entitled “SYSTEM AND METHOD FOR THE PROVISIONING OF DYNAMICALLY GENERATED CONTENT”, filed on May 31, 2006, by Rajkumar et al. discloses systems and methods for the provisioning of dynamically generated content and is incorporated herein as if set forth in full.
With reference again to
When performing certain functions associated with page cache 310, cache manager 312 can utilize a cache control table or some other data structure providing similar functionality to cache manager 312. With reference now to
In some embodiments, cache directory 378 and page identifier 380 for a particular entry 361 can be derived using a one-way hash of the URL 376 of that page 340. More particularly, a hash function can be chosen so that, for any two URLs, the resulting hashes will most certainly differ even when the particular pages 340 have relatively small differences between them. For instance, a comparison of entries 370 and 372 illustrates that even a very small change (for instance, the difference between “Support1” and “Support2” in URLs) can result in widely different hash values. Thus, the hash function can produce a unique hash for each URL 376. One suitable hash function is Message-Digest algorithm (MD5) which produces a 128-bit hash value. Other cryptographic hash functions and digital finger printing methods may also be suitable for implementations. For exemplary teachings on managing caches using hashed URLs, readers are directed to co-pending U.S. patent application Ser. No. 12/206,909, entitled “SYSTEM AND METHOD FOR MANAGING LARGE FILE SYSTEM-BASED CACHES”, and filed Sep. 9, 2008, which is incorporated herein by reference.
In some embodiments, each page identifier 380 can be derived from the hash of URL 376 corresponding to a particular page 340. In some embodiments, each cache directory 378 can be derived from portions of a hash of URL 376 corresponding to a particular page 340 and, in some embodiments, variation information pertaining thereto. Referring to
With continuing reference to
The above-described TTL approach has several limitations. For example, stale pages 340 may remain in page cache 310 between TTL driven regenerations. However, content, on which pages 340 depend, may be updated, deleted, or created, from time-to-time by content manager 306
The above-described TTL approach may also cause some non-stale, valid pages 340 to be regenerated needlessly. Such needless page regenerations can occur when certain cached pages 340 are relatively stable compared to their TTL entries 382. Thus, some cached pages 340 might be regenerated too frequently under the TTL approach, wasting network and processing resources.
Regeneration entries 386 of cache control table 360 can indicate whether a page may be regenerated or not. Cache manager 312 can decide whether or not to regenerate a particular page 340. When cache manager 312 receives an invalidation event for a particular page 340, cache manager 312 can kill that page 340 if regeneration entry 386 indicates that page 340 should not be regenerated. If regeneration entry 386 indicates that that page 340 may be regenerated, cache manager 312 can compare information regarding how often that page 340 is accessed (for instance, the last access time) to determine whether that page 340 is accessed frequently enough to make regeneration desirable. If so, cache manager 312 can issue an appropriate regeneration request to page generator 304. If not, cache manager 312 can delete page 340 or remove references to page 340 from page cache 310.
In some embodiments, hash value 702 corresponding to an URL for a particular page 340 is used to identify that particular page 340. For example, dependency 706 for a particular page 340 may contain a hash value of “QWERTYUIOPPASRASDFGH” referencing that particular page 340 and a reference to object 801, indicating that this particular page 340 depends on object 801. The same particular page 340 may also depend on object 802 according to dependency 708. Another page 340, as indicated by dependencies 710, 712, and 714, may depend on object 801, object 804, and object 810. In some embodiments, modification to a single object may invalidate a page, regardless whether that page also depends on other objects. In some embodiments, modification to a single object may invalidate more than one page. For example, suppose object 801 of
With continuing reference to
Dependency table 700 also illustrates one embodiment of “set dependencies” 703. Set dependencies 703 can include collections of objects 342 and 344 as reflected by various object entries 704. As illustrated by
Still referring to
In some embodiments, dependency manager 316 (of
With reference again to
Content management system 324 can allow certain actors 320 to create, maintain, modify, update, and delete content including objects 342 and 344 stored in content database 308. Content management system 324 can publish managed content to a deployment agent at the deployment stage. In some embodiments, this deployment agent incorporates invalidation generator 314. In some embodiments, invalidation generator 314 can have access to a version of the managed content or some versioning information of the managed content. In some embodiments, invalidation generator 314 may store a version of the managed content or some versioning information locally at the deployment stage.
Invalidation generator 314 may determine, based on the modifications to objects 342 and 344, what, if any, invalidation events should be produced and sent to dependency manager 316 of content delivery system 322. More specifically, by comparing the newly published content with the previous version, invalidation generator 314 can determine whether one or more objects 342 and 344 have been modified since the last publication. In some embodiments, for each object modification, invalidation generator 314 can produce and send to dependency manager 316 an invalidation event correspondingly.
Dependency manager 316 can receive the invalidation events from invalidation generator 314 and store them in a queue or other data structure. By comparing object modification information contained in the invalidation events and dependency information stored in dependency database 318, dependency manager 316 can determine if any page 340 is to be invalidated based on its dependency on an object that has been modified. In some embodiments, a single page 340 can be invalidated based on a single invalidation event. For each page 340 that is to be invalidated, dependency manager 316 can output a page invalidation notification to cache manager 312 accordingly.
In operation, system 300 can create new versions of pages 340, invalidate cached pages 340, and regenerate pages 340. In a cache hit scenario, request handler/cache reader 303 can serve a particular requested page 340 from page cache 310 via cache manager 312. In a cache miss scenario, a particular requested page 340 cannot be found in page cache 310). In such cases, request handler 303 can request that page generator 304 generate the particular requested page 340. In generating the requested page 340, page generator 304 can determine dependencies 701 and 703 for the requested page 340. Page generator 304 can send the particular requested page 340 and corresponding dependencies 701 and 703 to request handler 303 via capture filter 305. Request handler 303 can serve that page 340 to user device 302. Capture filter 305 can forward the newly generated page 340 to dependency manager 316 along with dependencies 701 and 703. Dependency manager 316 can store dependencies 701 and 703 in dependency database 318 and forward the newly generated page 340 to cache manager 312. Cache manager 312 can then write the recently requested, newly generated page 340 to page cache 310, thereby overwriting stale page 340. On the next request for that same particular page 340, request handler 303 can serve that particular page 340 from page cache 310. Page 340 may reside in page cache 310 for some time during which one or more objects 342 and 344 in content database 308 may be modified or otherwise updated.
When invalidation generator 314 detects that a modification has occurred to a particular object 355, it can generate an invalidation event and send it to dependency manager 316. Dependency manager 316 can receive the invalidation event and check dependency database 318 for and all pages 340 that might depend on object 355. In cases in which a particular page 340 depends on object 355, dependency manager 316 can send cache manager 312 a page invalidation notification indicating that that cached page 340 may have become invalid. Cache manager 312 can request page generator 304 to regenerate a new version of page 340. Page generator 304 then regenerates page 340 and determine page dependencies as described above.
Page generator 304, in regenerating page 340, can read objects 342 and 344 (including object 355) from content database 308 via content manager 306. In some situations, page generator 304 might only read object 355 which has been modified since page 340 was last regenerated. In any case, at some time later, page generator 304 can finish regenerating a new version of page 340 and send it to request handler 303.
After page 340 is regenerated, cache manager 312 can replace cached page 340 with regenerated page 340 in page cache 310. The regenerated page 340 or a version thereof can be served to requesting users via request handler 303. In the meantime, though, object 355 (or some other object 342 or 344 on which the regenerated version of page 340 might depend) may have been modified again by some actor 320. Thus, page 340 may be invalid again even before 1) page generator 304 finishes regenerating it; 2) request handler 303 serves regenerated page 340 to some end user; or 3) cache manager 312 writes regenerated page 340 to page cache 310. The object modifications occurring during page generation can be deemed “overlapping modifications”.
Some embodiments can include provisions for preventing overlapping modifications from causing invalidated pages 340 to be written to page cache 310. More particularly, when page generator 304 begins regenerating new versions of pages 340 (or begins generating new pages 340), page generator 304 can notify dependency manager 316 that it has begun a page generation session associated with certain pages 340 and objects 342 and 344. Dependency manager 316 can register such a regeneration session and monitor incoming invalidation events for overlapping modifications affecting objects 355 on which page 340 might depend (and for other modifications affecting page 340 if desired).
When dependency manager 316 receives a second, and overlapping, invalidation event during the session, dependency manager 316 can retain the previous and current invalidation events rather than discarding them. In some embodiments, dependency manager 316 may store incoming invalidation events locally, in dependency database 318, or in some other data structure. In the meantime, page generator 304 can finish regenerating a new version of the particular affected page 340 and notify dependency manager 316 that the regeneration session is complete. Page generator 304 can send dependency manager 316 regenerated page 340 and dependencies 701 and 703 associated therewith (via capture filter 305).
Dependency manager 316 can receive regenerated page 340 and dependencies 701 and 703 from page generator 304 and determine, based on invalidation events accumulated during the session and dependency information stored in dependency database 318, if any overlapping object modifications have occurred during the session. If so, the newly generated page may be invalidated.
As discussed previously, in some embodiments, dependency manager 316 can maintain a list (or other structure) in dependency database 318 pertaining to object modifications. Thus, dependency manager 316 can traverse the list back to such time as when page generator 304 began the page regeneration session searching for overlapping modifications. When dependency manager 316 determines that at least one overlapping object modification exists, dependency manager 316 can request that cache manager 312 invalidates the subject page via a page invalidation notification. Cache manager 312 can request invalidated pages 340 be regenerated as described above.
In some embodiments, when dependency manager 316 determines that no overlapping modifications exist, dependency manager 316 can notify cache manager 312 to write the regenerated page 340 to page cache 310. With continuing reference to
Thus, in some embodiments, instead of having regenerated pages 340 written to page cache 310, dependency manager 316 can notify cache manager 312 to store a regenerated page 340 in a temporary location in page cache 310. Cache manager 312 can acknowledge the temporary storage requested by dependency manager 316. Dependency manager 316 can then determine whether overlapping modifications have occurred during the write operation. If so, dependency manager 316 can notify cache manager 312 to invalidate the particular affected page 340. Cache manager 312 can request regeneration of the invalidated page 340 which is cached at a temporary location. If no overlapping object modifications have occurred while writing the regenerated page 340 to a temporary location, dependency manager 316 can request that cache manager 312 move the regenerated page 340 to a permanent location in page cache 310. In some embodiments, the above described process can be repeated.
Thus, system 300 can be utilized to invalidate and, when desired, regenerate pages when events occur which modify objects 342 and 344 on which various pages 340 may depend. However, some events can cause certain pages 340 to become stale which do not necessarily modify any particular object 342 and 344 or the content therein. For instance, when page 340 depends on the membership of a set of objects 342 and 344, changes to the membership of that set can cause page 340 to become stale. More particularly, if a certain object 342 or 344 in the set on which some page 340 depends is deleted, the membership of that set changes accordingly. In such situations, cached page 340 might still contain information from the particular deleted object 342 and 344 even though content database 308 no longer contains that particular object 342 and 344. When a particular object 342 and 344 is created and page 340 depends on a set which contains that particular newly created object 342 and 344, cached page 340 might not contain that particular recently created object 342 and 344 while content database 308 might contain that particular object. One situation, of many, in which pages 340 depend on sets of objects 342 and 344 can be when pages 340 rely on one or more queries (which identify those sets of objects 342 and 344 and insert those sets of objects 342 and 344 into pages 340).
Another aspect of objects 342 and 344 which can affect their membership in sets can be attributes of objects 342 and 344. Attributes of object 342 and 344 can include their titles, bodies, etc. for which each object 342 and 344 can have various values. Various attributes can be associated with objects 342 and 344 according to the type of object 342 and 344 that particular objects 342 and 344 belong to. Since some pages 340 can include certain objects 342 and 344 depending on whether their attributes meet some criteria, modifications affecting those object 342 and 344 attributes can cause some pages 340 to become stale. Events which alter the membership of various sets of objects 342 and 344 (by, for example, creating or deleting objects 342 and 344 in the sets or changing object 342 and 344 attributes), can be deemed “contextual invalidation events” herein.
In some embodiments, objects such as articles can be associated with channels 739 as illustrated by
In some embodiments, pages 340 can be generated from page templates which can include objects 344 which can provide access to, and control access to, content from channels 739. One such object 344 can be query object 344′. Query object 344′ can, at run-time, identify sets of objects 342 for inclusion in pre-generated pages 340. Query object 344′ can include criteria for identifying objects 342 for inclusion in the set. In one embodiment, query object 344′ can be specified as follows:
When executed, query object 344′ can retrieve objects of type “Article” which are associated with the current channel 739. When pages 340 are being generated for a particular news channel 739, query object 344′ can retrieve all of the article objects 342 associated with that particular news channel 739. As discussed herein, cached pages 340 dependent on page templates containing query object 344′ can become stale when new article objects 342 are added to the particular current channel 739. Such cached pages 340 can also become stale should particular article objects 342 be deleted from the particular current channel 739. Cached pages 340 can also become stale, as discussed above, should attributes of particular article objects 342 and 344 be modified.
System 300 of
Contextual dependencies (such as contextual dependencies 732, 734, 736, and 738 of
“Filters” can be qualifiers that can limit the sets of objects 342 and 344 identified by targets and specifiers. For query object 344′, a particular filter can be the name of the Article object type, indicating that this particular contextual dependency can apply only to article objects 342 which are associated with the current channel 739. Filters can be restrictive (as in the foregoing) or empty. In some embodiments, filters can apply to object 342 and 344 attributes and other features associated with objects 342 and 344, channels 339, etc. Filters can be chosen to balance expressiveness (and precision in the sets of returned objects 342 and 344) and the amount of processing resources potentially utilized by invalidation generator 314 in applying filters. “Events” indicate whether contextual dependencies apply to object 342 and 344 creations, object 342 and 344 deletions, object 342 and 344 and object 342 and 344 attribute modifications, etc.
When the query object 344′ is executed in the context of channel “DEF” (see
The first of these particular contextual dependencies 732 can indicate that certain cached pages 340 can be invalidated whenever an article object 342 (which is associated with channel “ABC”) is created or deleted. Invalidation may be desirable for these cached pages 340 because query object 344′ might produce different results whenever article objects 342 associated with channel ABC are created or deleted. However, pages 340 affected by this first particular contextual dependency 732 might not be invalidated if objects 342 and 344 of some type other than article are created or deleted because this particular contextual dependency 732 restricts itself to article objects 342. Thus, when dependency manager 316 determines whether contextual invalidation events apply to pages 340 affected by this particular contextual dependency 732, processing resources may be saved by only comparing contextual invalidation events which apply to objects 342 of type article to this particular contextual dependency. Filters such as the foregoing article filter can also avoid unnecessary page 340 invalidations by limiting the scope of contextual dependencies such as contextual dependency 732.
The second of these particular contextual dependencies 734 can indicate that pages 340 can be invalidated whenever article objects 342 associated with channel DEF are modified, but only if the modification involves only attributes in the “moAttrs” attribute set. In one embodiment, the moAttrs attribute set can be a set of standard attributes shared by all objects 342 and 344 and can include such attributes as a “System Name” attribute. Thus, when an object 342 and 344 associated with channel DEF is modified, but the modification fails to involve an attribute in the moAttrs set, corresponding pages 340 will not be invalidated. However, corresponding pages 340 might have other direct dependencies 701 and 703 for some of objects 342 and 344 retrieved by query object 344′. Accordingly, some corresponding pages 340 might be affected by these other dependencies 701 and 703.
As discussed above, query object 344′ can result in the two foregoing contextual dependencies 732 and 734. Other dependencies 701 and 703 might be created for pages 340 which depend on query object 344′ because, for instance, query object 344′ inserts objects 342 into these pages 340. These inserted objects 342 might therefore give rise to dependencies 701 and 703. For other, more complex query objects 344′, more contextual dependencies and dependencies 701 and 703 might be created depending on, respectively, the complexity of query objects 344′ and the particular objects 342 returned thereby.
Thus, as illustrated by
Dependency manager 316 can receive contextual dependencies and contextual invalidation events from invalidation generator 314. Contextual dependencies (such as contextual dependencies 732, 734, 736, and 738) can be stored in dependency database 318 by dependency manager 316. When dependency manager 316 receives contextual invalidation events, dependency manager 316 can compare contextual invalidation events to contextual dependencies in dependency database 318 to determine which cached pages 340 might be affected by the contextual invalidation events. When cached pages 340 are affected by contextual invalidation events, dependency manager 316 can issue corresponding page invalidation notifications 359 to cache manager 312.
System 300 can operate to invalidate and (when desired) regenerate pages 340 in content cache 310. System 300 can operate to prevent overlapping modifications (whether event driven or contextual) from causing invalidated pages 340 to remain in, or re-appear in, content cache 310. System 300 can, in some embodiments, generate both event driven page 340 invalidations and contextual event driven page 340 invalidations and regenerate affected pages 340 accordingly.
Embodiments provide systems and methods for regenerating cached World Wide Web pages, thereby reducing the amount of stale data in the cache. When stale data happens to be in the cache, embodiments reduce the time during which such stale data resides in the cache. Embodiments reduce, if not eliminate, the likelihood that overlapping invalidation events can allow invalidated pages to remain in the cache. Embodiments provide systems and methods in which pages can be invalidated based on events which can pertain to the validity of the pages. In some embodiments, invalidated pages can be regenerated when such invalidation events occur. Embodiments also allow invalidated pages to be discarded when events occur which give rise to their invalidation. Some embodiments reduce, if not eliminate, page regenerations (and the associated processing and network overhead) associated with time-to-live approaches to reducing stale pages in caches.
Embodiments provide methods and systems which allow pages to be invalidated based on changes in membership of sets of objects underlying the pages. Embodiments allow pages which depend on query objects to be updated when objects which should be returned by the query are created, deleted, or modified in such a manner that attributes associated with the objects are modified. Various embodiments provide content of higher quality to end users than previously possible. Various embodiments provide higher quality content delivery for content management systems than previously possible. Embodiments save space in and processing resources associated with content caches.
Although embodiments have been described in detail herein, it should be understood that the description is by way of example only and is not to be construed in a limiting sense. It is to be further understood, therefore, that numerous changes in the details of the embodiments and additional embodiments will be apparent, and may be made by, persons of ordinary skill in the art having reference to this description. It is contemplated that all such changes and additional embodiments are within scope of the claims below and their legal equivalents.
|Brevet cité||Date de dépôt||Date de publication||Déposant||Titre|
|US5202982||27 mars 1990||13 avr. 1993||Sun Microsystems, Inc.||Method and apparatus for the naming of database component files to avoid duplication of files|
|US5473772||2 sept. 1993||5 déc. 1995||International Business Machines Corporation||Automatic update of static and dynamic files at a remote network node in response to calls issued by or for application programs|
|US5504879||16 juil. 1992||2 avr. 1996||International Business Machines Corporation||Resolution of relationship source and target in a versioned database management system|
|US5740430||6 nov. 1995||14 avr. 1998||C/Net, Inc.||Method and apparatus for server-independent caching of dynamically-generated customized pages|
|US5740730||3 sept. 1996||21 avr. 1998||Micron Electronics, Inc.||Apparatus for depositing solder and adhesive materials onto a printed circuit board|
|US5946697||22 avr. 1997||31 août 1999||Microsoft Corporation||Rapid transfer of HTML files|
|US6026413 *||1 août 1997||15 févr. 2000||International Business Machines Corporation||Determining how changes to underlying data affect cached objects|
|US6029175||7 juin 1996||22 févr. 2000||Teknowledge Corporation||Automatic retrieval of changed files by a network software agent|
|US6151607 *||28 avr. 1999||21 nov. 2000||Microsoft Corporation||Database computer system with application recovery and dependency handling write cache|
|US6151624||3 févr. 1998||21 nov. 2000||Realnames Corporation||Navigating network resources based on metadata|
|US6178461||8 déc. 1998||23 janv. 2001||Lucent Technologies Inc.||Cache-based compaction technique for internet browsing using similar objects in client cache as reference objects|
|US6192415||19 juin 1998||20 févr. 2001||International Business Machines Corporation||Web server with ability to process URL requests for non-markup language objects and perform actions on the objects using executable instructions contained in the URL|
|US6198824||11 mai 1999||6 mars 2001||Verizon Laboratories Inc.||System for providing secure remote command execution network|
|US6272492||21 nov. 1997||7 août 2001||Ibm Corporation||Front-end proxy for transparently increasing web server functionality|
|US6408360||25 janv. 1999||18 juin 2002||International Business Machines Corporation||Cache override control in an apparatus for caching dynamic content|
|US6487641||5 sept. 2000||26 nov. 2002||Oracle Corporation||Dynamic caches with miss tables|
|US6571246||22 mars 2000||27 mai 2003||Ipac Acquisition Subsidiary I, Llc||Automatic data collection and workflow management in a business process|
|US6591266||14 août 2000||8 juil. 2003||Nec Corporation||System and method for intelligent caching and refresh of dynamically generated and static web content|
|US6651217||1 sept. 1999||18 nov. 2003||Microsoft Corporation||System and method for populating forms with previously used data values|
|US6697844||5 juin 2000||24 févr. 2004||Lucent Technologies, Inc.||Internet browsing using cache-based compaction|
|US6701428||28 avr. 1997||2 mars 2004||Apple Computer, Inc.||Retrieval of services by attribute|
|US6725333 *||22 avr. 1999||20 avr. 2004||International Business Machines Corporation||System and method for managing cachable entities|
|US6754621||6 oct. 2000||22 juin 2004||Andrew Cunningham||Asynchronous hypertext messaging system and method|
|US6760813||20 déc. 2001||6 juil. 2004||Cisco Technology, Inc.||Devices, softwares and methods for preemptively updating expiring entries in a cache memory to anticipate future inquiries|
|US6772203||9 mai 2002||3 août 2004||Pivia, Inc.||Updating data objects for dynamic application caching|
|US6785769||4 août 2001||31 août 2004||Oracle International Corporation||Multi-version data caching|
|US6850941||21 déc. 2001||1 févr. 2005||Vignette Corporation||Method and system for native-byte form handling|
|US7013289||21 févr. 2001||14 mars 2006||Michel Horn||Global electronic commerce system|
|US7024452||15 juil. 2002||4 avr. 2006||Vignette Corporation||Method and system for file-system based caching|
|US7096418 *||12 juin 2000||22 août 2006||Persistence Software, Inc.||Dynamic web page cache|
|US7137009||6 janv. 2000||14 nov. 2006||International Business Machines Corporation||Method and apparatus for securing a cookie cache in a data processing system|
|US7188216||11 déc. 2003||6 mars 2007||Vignette Corporation||Method and system for an extensible caching framework|
|US7343422||26 avr. 2001||11 mars 2008||Adara Networks, Inc.||System and method for using uniform resource locators to map application layer content names to network layer anycast addresses|
|US7360025||11 déc. 2003||15 avr. 2008||O'connell Conleth||Method and system for automatic cache management|
|US7398304||23 juin 2003||8 juil. 2008||Microsoft Corporation||General dependency model for invalidating cache entries|
|US7752394||1 févr. 2007||6 juil. 2010||Vignette Software Llc||Method and system for an extensible caching framework|
|US7818506||10 juil. 2007||19 oct. 2010||Vignette Software Llc||Method and system for cache management|
|US7899991||21 juin 2010||1 mars 2011||Vignette Software Llc||Method and system for an extensible caching framework|
|US8041893||9 sept. 2008||18 oct. 2011||Vignette Software Llc||System and method for managing large filesystem-based caches|
|US20010032254||29 mai 1998||18 oct. 2001||Jeffrey C. Hawkins||Method and apparatus for wireless internet access|
|US20010034771||12 janv. 2001||25 oct. 2001||Sun Microsystems, Inc.||Network portal system and methods|
|US20010037407||23 mars 2001||1 nov. 2001||Zvetan Dragulev||System and method for managing user-specific data|
|US20020065912||30 nov. 2001||30 mai 2002||Catchpole Lawrence W.||Web session collaboration|
|US20020165877||7 déc. 2000||7 nov. 2002||Malcolm Jerry Walter||Method and apparatus for filling out electronic forms|
|US20020178187||19 déc. 2001||28 nov. 2002||Rasmussen Brett D.||Electronically signed HTML forms|
|US20020194219||15 avr. 2002||19 déc. 2002||Bradley George Wesley||Method and system for cross-platform form creation and deployment|
|US20030078964||4 juin 2002||24 avr. 2003||Nct Group, Inc.||System and method for reducing the time to deliver information from a communications network to a user|
|US20030217117||29 janv. 2003||20 nov. 2003||Noah Dan||Method and system for web management|
|US20040030697||31 juil. 2002||12 févr. 2004||American Management Systems, Inc.||System and method for online feedback|
|US20040030746||16 juil. 2003||12 févr. 2004||Sathyanarayanan Kavacheri||Hierarchical client detection in a wireless portal server|
|US20040107319||3 déc. 2002||3 juin 2004||D'orto David M.||Cache management system and method|
|US20040205165||21 janv. 2004||14 oct. 2004||Eplication Networks Ltd.||Method for improving quality of service from an Internet server employing heuristic optimization of downloading|
|US20040205452||17 août 2001||14 oct. 2004||Fitzsimons Edgar Michael||Apparatus, method and system for transforming data|
|US20060136472||20 déc. 2004||22 juin 2006||Venkateswararao Jujjuri||Achieving cache consistency while allowing concurrent changes to metadata|
|US20060184572||11 févr. 2005||17 août 2006||Microsoft Corporation||Sampling method for estimating co-occurrence counts|
|US20100262785||21 juin 2010||14 oct. 2010||Rajkumar N Isaac||Method and System for an Extensible Caching Framework|
|US20110035553||14 oct. 2010||10 févr. 2011||Lee Shepstone||Method and system for cache management|
|US20120011324||20 sept. 2011||12 janv. 2012||Kin-Chung Fung||System and method for managing large filesystem-based caches|
|1||Chen et al., "Wormhole Caching with HTTP PUSH Method for Satellite-Based Web Content Multicast and Replication System" Workshop 99, pp. 1-14, 1999.|
|2||Dias et al., "A Smart Internet Caching System" by University of Moratuwa, Sri Lanka, 13 pgs, 1996.|
|3||Fielding et al. "13 Caching in HTTP" part of Hypertext Transfer Protocol-HTTP/1.1, The Internet Society, 20 pgs, 1999.|
|4||Fielding et al. "13 Caching in HTTP" part of Hypertext Transfer Protocol—HTTP/1.1, The Internet Society, 20 pgs, 1999.|
|5||Notice of Allowance for U.S. Appl. No. 12/206,909, mailed Jul. 12, 2011, 27 pgs.|
|6||Notice of Allowance for U.S. Appl. No. 12/208,072, mailed Feb. 27, 2012, 2 pgs.|
|7||Notice of Allowance for U.S. Appl. No. 12/904,937, mailed Apr. 24, 2012, 6 pages.|
|8||Notice of Allowance for U.S. Appl. No. 13/237,236, mailed Mar. 9, 2012, 4 pgs.|
|9||Notice of Allowance issued in U.S. Appl. No. 12/819,985 mailed Dec. 15, 2010, 10 pgs.|
|10||Office Action for U.S. Appl. No. 12/208,072, mailed Sep. 23, 2011, 10 pgs.|
|11||Office Action for U.S. Appl. No. 12/208,934 mailed Oct. 17, 2011, 11 pages.|
|12||Office Action for U.S. Appl. No. 12/208,934, mailed Mar. 27, 2012, 11 pgs.|
|13||Office Action for U.S. Appl. No. 12/208,934, mailed May 10, 2011, 25 pgs.|
|14||Office Action for U.S. Appl. No. 12/904,937, mailed Dec. 1, 2011, 10 pgs.|
|15||Office Action for U.S. Appl. No. 12/904,937, mailed Jan. 5, 2011, 12 pgs.|
|16||Office Action for U.S. Appl. No. 12/904,937, mailed May 25, 2011, 11 pgs.|
|17||Office Action for U.S. Appl. No. 12/904,937, mailed Sep. 2, 2011, 13 pgs.|
|18||Office Action issued in U.S. Appl. No. 10/733,742, dated Aug. 22, 2007, 14 pgs.|
|19||Office Action issued in U.S. Appl. No. 10/733,742, dated Feb. 7, 2007, 12 pgs.|
|20||Office Action issued in U.S. Appl. No. 10/733,742, dated Jan. 17, 2006, 10 pgs.|
|21||Office Action issued in U.S. Appl. No. 10/733,742, dated Jun. 6, 2006, 15 pgs.|
|22||Office Action issued in U.S. Appl. No. 10/733,742, dated Sep. 15, 2006, 8 pgs. .|
|23||Office Action issued in U.S. Appl. No. 10/733,798, dated Jan. 3, 2006, 9 pgs.|
|24||Office Action issued in U.S. Appl. No. 10/733,798, dated May 31, 2006, 14 pgs.|
|25||Office Action issued in U.S. Appl. No. 11/701,193 dated Mar. 31, 2009, Rajkumar, 9 pages.|
|26||Office Action issued in U.S. Appl. No. 11/701,193, dated Oct. 2, 2008, 9 pgs.|
|27||Office Action issued in U.S. Appl. No. 11/701,193, mailed Oct. 22, 2009, 10 pgs.|
|28||Office Action issued in U.S. Appl. No. 11/825,909 mailed Mar. 5, 2010,11 pgs.|
|29||Office Action issued in U.S. Appl. No. 11/825,909 mailed Sep. 29, 2009, 9 pgs.|
|30||Office Action issued in U.S. Appl. No. 12/819,985 mailed Aug. 2, 2010, 9 pgs.|
|Brevet citant||Date de dépôt||Date de publication||Déposant||Titre|
|US8438336||20 sept. 2011||7 mai 2013||Open Text S.A.||System and method for managing large filesystem-based caches|
|US8452925||14 oct. 2010||28 mai 2013||Open Text S.A.||System, method and computer program product for automatically updating content in a cache|
|US8463998||10 sept. 2008||11 juin 2013||Open Text S.A.||System and method for managing page variations in a page delivery cache|
|US8832387||14 sept. 2012||9 sept. 2014||Open Text S.A.||Event-driven regeneration of pages for web-based applications|
|US8850138||14 sept. 2012||30 sept. 2014||Open Text, S.A.||System and method for managing page variations in a page delivery cache|
|US9081807||30 juil. 2014||14 juil. 2015||Open Text S.A.||Event-driven invalidation of pages for web-based applications|
|US9088463 *||11 mai 2012||21 juil. 2015||Amazon Technologies, Inc.||Container contract for data dependencies|
|US9160709||4 sept. 2014||13 oct. 2015||Open Text S.A.||System and method for managing page variations in a page delivery cache|
|US9380022||21 sept. 2015||28 juin 2016||Open Text S.A.||System and method for managing content variations in a content deliver cache|
|US9418353 *||20 déc. 2011||16 août 2016||Akamai Technologies, Inc.||Methods and systems for delivering content to differentiated client devices|
|US9596316 *||3 févr. 2016||14 mars 2017||International Business Machines Corporation||Optimizing bandwidth usage and improving performance for web page caching|
|US9703885||7 juin 2016||11 juil. 2017||Open Text Sa Ulc||Systems and methods for managing content variations in content delivery cache|
|US9749437||10 janv. 2017||29 août 2017||International Business Machines Corporation||Optimizing bandwidth usage and improving performance for web page caching|
|US9749439||13 janv. 2017||29 août 2017||International Business Machines Corporation||Optimizing bandwidth usage and improving performance for web page caching|
|US20110035553 *||14 oct. 2010||10 févr. 2011||Lee Shepstone||Method and system for cache management|
|US20120203861 *||20 déc. 2011||9 août 2012||Akamai Technologies, Inc.||Methods and systems for delivering content to differentiated client devices|
|US20130086323 *||4 juin 2012||4 avr. 2013||Oracle International Corporation||Efficient cache management in a cluster|
|US20150074199 *||17 nov. 2014||12 mars 2015||Huawei Technologies Co., Ltd.||Document sharing method, system, and device|
|Classification aux États-Unis||711/133, 711/141, 711/E12.021|
|8 oct. 2008||AS||Assignment|
Owner name: VIGNETTE CORPORATION, TEXAS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MARTIN, JOHN H.;SCHEEVEL, MARK R.;REEL/FRAME:021652/0824
Effective date: 20080912
|11 janv. 2010||AS||Assignment|
Owner name: VIGNETTE SOFTWARE LLC, TEXAS
Free format text: INTELLECTUAL PROPERTY PURCHASE AGREEMENT;ASSIGNOR:VIGNETTE CORPORATION (4%);REEL/FRAME:023768/0708
Effective date: 20090717
Owner name: VIGNETTE LLC, TEXAS
Free format text: INTELLECTUAL PROPERTY PURCHASE AGREEMENT;ASSIGNOR:VIGNETTE CORPORATION (96%);REEL/FRAME:024006/0001
Effective date: 20090717
|11 janv. 2010||XAS||Not any more in us assignment database|
Free format text: INTELLECTUAL PROPERTY PURCHASE AGREEMENT;ASSIGNOR:VIGNETTE CORPORATION (96%);REEL/FRAME:023773/0404
|14 janv. 2010||AS||Assignment|
Owner name: VIGNETTE SOFTWARE LLC, TEXAS
Free format text: INTELLECTUAL PROPERTY PURCHASE AGREEMENT;ASSIGNOR:VIGNETTE LLC (96%);REEL/FRAME:023792/0470
Effective date: 20090717
|12 oct. 2011||AS||Assignment|
Owner name: VIGNETTE CORPORATION, TEXAS
Free format text: MERGER;ASSIGNOR:VIGNETTE SOFTWARE, LLC;REEL/FRAME:027077/0423
Effective date: 20100330
|13 oct. 2011||AS||Assignment|
Owner name: VIGNETTE OPERATING, LLC, TEXAS
Free format text: CERTIFICATE OF CONVERSION;ASSIGNOR:VIGNETTE CORPORATION;REEL/FRAME:027091/0009
Effective date: 20100624
|14 oct. 2011||AS||Assignment|
Owner name: VIGNETTE PARTNERSHIP, LP, TEXAS
Free format text: CERTIFICATE OF CONVERSION;ASSIGNOR:VIGNETTE OPERATING, LLC;REEL/FRAME:027066/0773
Effective date: 20100624
|19 déc. 2011||AS||Assignment|
Owner name: OPEN TEXT S.A., LUXEMBOURG
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:VIGNETTE PARTNERSHIP, LP;REEL/FRAME:027483/0205
Effective date: 20110725
|4 août 2016||FPAY||Fee payment|
Year of fee payment: 4
|13 sept. 2016||AS||Assignment|
Owner name: OPEN TEXT SA ULC, CANADA
Free format text: CERTIFICATE OF AMALGAMATION;ASSIGNOR:IP OT SUB ULC;REEL/FRAME:040019/0578
Effective date: 20160708
Owner name: OT IP SUB, LLC, DELAWARE
Free format text: IP BUSINESS SALE AGREEMENT;ASSIGNOR:OPEN TEXT S.A.;REEL/FRAME:040019/0627
Effective date: 20160701
Owner name: IP OT SUB ULC, CANADA
Free format text: CERTIFICATE OF CONTINUANCE;ASSIGNOR:OP IP SUB, LLC;REEL/FRAME:040019/0500
Effective date: 20160702