Dynamic content assembly on edge-of-network servers in a content delivery network

• US 20090150518A1
• Filed: 08/20/2001
• Published: 06/11/2009
• Est. Priority Date: 08/22/2000
• Status: Active Grant

• Current Assignee: Akamai Technologies, Inc.
• Original Assignee: Akamai Technologies, Inc.
• Inventors: Kagan, Marty, Lewin, Daniel M., Davis, Andrew Thomas, Parikh, Jay Gunvantral, Lewin, Anne E., Gendler, Samuel Dov
• Granted Patent: US 7,752,258 B2
• Time in Patent Office: Days
• US Class Current: 709/219
• CPC Class Codes: G06F 16/9574 of access to content, e.g. by caching
• CPC Class Codes: H04L 67/568 Storing data temporarily at an intermediate stage, e.g. caching

Abstract

The present invention enables a content provider to dynamically assemble content at the edge of the Internet, preferably on content delivery network (CDN) edge servers. Preferably, the content provider leverages an “edge side include” (ESI) markup language that is used to define Web page fragments for dynamic assembly at the edge. Dynamic assembly improves site performance by catching the objects that comprise dynamically generated pages at the edge of the Internet, close to the end user. The content provider designs and develops the business logic to form and assemble the pages, for example, by using the ESI language within its development environment. Instead of being assembled by an application/web server in a centralized data center, the application/web server sends a page template and content fragments to a CDN edge server where the page is assembled. Each content fragment can have its own cacheability profile to manage the “freshness” of the content. Once a user requests a page (template), the edge server examines its cache for the included fragments and assembles the page on-the-fly.

Claims

1. A method, operative at a network server, for processing a request for a container, wherein the container comprises markup identifying one or more content fragments and the container and each content fragment may have a distinct cache profile, comprising:

determining if the container is cached at the server or needs to be refreshed;

if the container is not cached at the server or needs to be refreshed, contacting an origin server or another network server to obtain the container;

instantiating a given processor selected based on a content type of the container;

processing the container to identify page assembly instructions and markup for a given content fragment;

determining if the given content fragment identified by the markup is cached at the server or needs to be refreshed; and

if the given content fragment identified by the markup is not cached at the server or needs to be refreshed, contacting an origin server or another network server to obtain the given content fragment;

assembling the given content fragment into the container according to the page assembly instructions; and

delivering the container having the given content fragment assembled therein as a response to the request.

2. The method as described in claim 1 the container comprises a first content type and the given content fragment comprises a second content type.

3. The method as described in claim 2 wherein the first content type differs from the second content type.

4. The method as described in claim 2 wherein the first content type is the same as the second content type.

5. The method as described in claim 1 wherein the processing step includes:

parsing the container to generate a given representation; and

processing the given representation to identify the page assembly instructions.

6. The method as described in claim 5 wherein the given representation is a parse tree.

7. The method as described in claim 5 further including the step of caching the given representation of the container to obviate the step of parsing the container upon receipt at the server of a subsequent request for the container.

8. The method as described in claim 1 wherein the network server is a content server in a content delivery network (CDN).

9. The method as described in claim 1 wherein the server communicates with the origin server or the other network server over a persistent connection.

10. A mechanism operative on a network server for assembling content fragments into a container, wherein the container comprises markup identifying one or more content fragments and the container and each content fragment may have a distinct cacheability and access profile, comprising:

a set of one or more processors, wherein a given processor is associated with a given content type;

an application programming interface (API) responsive to a request for the container or a given content fragment for (a) parsing markup and generating a representation of the markup, and (b) for instantiating a given processor to process the request depending on the given content type in the markup;

wherein the given processor serializes given data generated during the processing of the request according to the representation to generate a response.

11. The mechanism as described in claim 10 wherein the processor is an HTML processor.

12. The mechanism as described in claim 10 wherein the processor is an XSLT processor.

13. The mechanism as described in claim 10 wherein the processor is a Java processor.

14. The mechanism as described in claim 10 wherein the processor is a PHP processor.

15. The mechanism as described in claim 10 wherein the network server is a content delivery network (CDN) surrogate origin server having an object cache.

16. The mechanism as described in claim 10 wherein one or more processors are instantiated by the application programming interface to process a given request.

17. The mechanism as described in claim 16 wherein a first processor is a text processor that processes the container and a second processor is an XSLT processor that processes an XML content fragment.

18. The mechanism as described in claim 10 wherein a first processor is instantiated by the application programming interface as a parent processor and, thereafter, a second processor is instantiated by the application programming interface as a child processor.

19. The mechanism as described in claim 10 wherein the given representation is a parse tree.

20. An apparatus operating as a surrogate origin server in a content delivery network for receiving end user requests for a container, wherein the container comprises markup identifying one or more content fragments, comprising:

a cache;

a set of one or more processors, wherein a given processor is associated with a given content type; and

code responsive to a request for a container (a) for instantiating a base processor according to content provider-specific metadata, and (b) for instantiating one or more additional processors as needed by the base processor to thereby assemble given content fragments into the container to produce an assembled document;

wherein the container and each content fragment may each have a distinct cacheability and/or refresh profile.