International Business Machines Corporation

Michael Haden Conner

George Prentice Copeland

Matthew McClain

Gregory Alan Flurry

Nurcan Coskun

Lin Xu

Andrew R Martin

Marc Gregory Smith

Liane Elizabeth Acker

Arun Kwangil Iyengar

Craig Henry Becker

James R H Challenger

Christopher Shane Claussen

Benjamin Charles ZumBrunnen

Frank Richard Campagnoni

Erin Elizabeth Shepler

Bryce Allen Curtis

Eoin Lane

Jimmy Ming-Der Hsu

David Seager Renshaw

Wayne Elmo Vicknair

Larry K Raper

Scott Harrison Danforth

Simon Christopher Nash

Raghu Vishwanath Hudli

Venu P Banda

Stewart E Nicholas

Kevin J Greene

Dawn E Bezviner

A method, a system, an apparatus, and a computer program product are presented for a fragment caching methodology. After a message is received at a computing device that contains a cache management unit, a fragment in the message body of the message is cached. Subsequent requests for the fragment at the cache management unit result in a cache hit. A FRAGMENTLINK tag is used to specify the location in a fragment for an included or linked fragment which is to be inserted into the fragment during fragment or page assembly or page rendering. A FRAGMENTLINK tag may include a FOREACH attribute that is interpreted as indicating that the FRAGMENTLINK tag should be replaced with multiple FRAGMENTLINK tags. The FOREACH attribute has an associated parameter that has multiple values that are used in identifying multiple fragments for the multiple FRAGMENTLINK tags.

Method and system for caching message fragments using an expansion attribute in a fragment link tag

Mapping a source identifier in a source identifier space to a target identifier in a target identifier space using a hash-based computation that is stable over time with respect to a change in the number of target identifiers. A data item identifiable by a source identifier is associated with some type of computational resource that is represented by a target object identifiable by one or more target identifiers. The set of target objects is dynamically variable. After hashing the source identifier to produce an index position of an entry in a table, a target identifier is retrieved from the table entry. Each entry in the table is related to a single target identifier based on a nearness computation that depends upon the table index position of the table entry and a target identifier for the related target.

Stable hash-based mapping computation for a dynamically varying target set

A system and method are disclosed, according to which, the responsiveness of client/server-based distributed web applications operating in an object-oriented environment may be improved by detecting and handling affinity breaks between a client and server. Affinity exists when a client's requests are all routed to the same server. This is often the case, for example, during secure online transactions. A problem occurs when the preferred server becomes temporarily unavailable, and the client's requests are directed to a different server. When the original server is restored, it must detect the fact that its affinity with the client was disrupted, and any client-specific data in its cache may be invalid. In an exemplary embodiment of the system and method disclosed herein, an 'affinity command' is exchanged between the client and the server during each client request. The affinity command contains a user ID associated with the client and a 'generation ID', which is unique for each request. When a request is received from a client, the server examines the generation ID in the accompanying affinity command and compares it to its internally recorded value. If they match, the server knows it has not missed any requests. In this case, the server updates the generation ID and sends the new value back to the client, along with the requested cache entry. If the generation ID received from the client fails to match the recorded value, an affinity break is detected, and the server updates its cache from the database.

Detecting and handling affinity breaks in web applications

Provided is a Web Services Response Template (WSRT) that addresses the problems of efficiency and robustness to change in Web Services response by allowing a requestor to explicitly specify, in a response template what information is to be returned by the request. A requestor of a web service gets just the information it needs; different requestors of the same operation may get different information; and a responder sends the requestor only what is asked for so there is no problem when new information becomes available. WSRTs are specifically designed to allow the type of control needed in program-to-program (P2P) communication, while being very efficiently and simply processed by a web service. Thus, WSRTs address difficulties that arise in typical distributed, P2P communication without adding much overhead or complexity to either a service requester or a service provider. The efficiency and flexibility afforded by WSRTs is essential to emerging enterprise architectures based on SOA (Service Oriented Architecture).

Web services response templates

A method for communicating among a plurality of peer nodes in a network environment is provided. A discovery command is communicated from a current peer node to at least one neighbor peer node, the neighbor peer node in communication with the current peer node. An aggregated list of peer nodes is received at the current peer node, the aggregated list of peer nodes comprising information about at least one peer node in communication with the at least one neighbor node. Programs and systems of using the method are also provided.

Method and system for peer to peer communication in a network environment

A method for serving a web page uses eXtensible Markup Language (XML) server pages. The first time a page is accessed, a given flat file is parsed into an XML Document Object Model (DOM), and required tag libraries are loaded. The DOM tree is then traversed, preferably in a depth-first, inside-out manner to locate custom tags. Upon locating a custom tag, if the tag is registered as a Java object, the object is loaded. A process method is then called on the object, passing the custom tag's tree node. The Java object then examines the custom tag and replaces it with an object, e.g., script code. Alternatively, if the tag is registered as an XSL stylesheet, the stylesheet is loaded and passed, together with the DOM, to an XSL processor. The processor applies the template to the custom tag and replaces it with given script code. Once all custom tags are reduced to HTML and script code, the DOM is compiled into a Java servlet to service the client request.

Extensible markup language (XML) server pages having custom document object model (DOM) tags

A table format object is used to format a dynamic HTML table at a web server. To facilitate the development of a dynamic server page for use in serving the dynamic table, first and second representations are created and made available for display to a page developer, e.g., in a web browser. The first representation illustrates how the HTML table will appear when formatted on a page by the table format object. The first representation includes given table attribute elements. The second representation is preferably online documentation for the table format object that includes, for each table attribute element, a set of methods that are available on the table format object. According to the invention, a given table attribute in the first representation is bidirectionally linked to its corresponding set of methods in the second representation to enable the developer to easily identify how given attributes in the table behave and how to resolve potential conflicts between these attributes.

Method for providing a visual representation of dynamic HTML table attributes

A system and method are disclosed, according to which, the responsiveness of client/server-based distributed web applications operating in an object-oriented environment may be improved by storing both JSPs and commands in the same cache. Some of the code and data structures required for caching JSPs are the same as for commands, and are saved in a common area of the cache. A second area of the cache is reserved for code and data specific to JSPs, and a third area is reserved for code and data specific to commands. This arrangement avoids the difficulty of judiciously apportioning the available cache between JSPs and commands.

Integrated JSP and command cache for web applications with dynamic content

A method operative at a server for generating a table having dynamic data. According to the method, a page developer may specify a given table cell in the table for conditional treatment. In response to a request for the table received from a client browser, the table is populated with dynamic data, preferably by instantiating a table format object. If the dynamic data in the table cell meets a given condition, the table cell is highlighted. Using this technique, the page developer may conditionally highlight a particular cell based on the characteristics of the dynamic data to be presented in the cell.

Conditional highlighting of given cells in a dynamic HTML table

A system and method are disclosed, according to which, the responsiveness of client/server-based distributed web applications operating in an object-oriented environment may be improved by cofetching read only commands. In an exemplary embodiment, the system and method are implemented by defining special preExecute and postExecute methods of cacheable commands. The preExecute method of a requested command may be invoked to execute secondary commands and then return them to the requesting client. The postExecute method of a requested command may be invoked to place the returned commands in a cache, along with the requested command. In this manner, a single request can be used to execute, retrieve and cache multiple related commands. Cofetched commands are designated by the application developer when the requested command and its associated methods are created, and may be chosen based on their anticipated use in conjunction with the requested command. For example, a log-on command may cofetch other user authentication commands, since they are generally required immediately after the user logs on. Cofetching avoids the need to issue a separate request for every command.

Cofetching in a command cache

A user contracts with an application service provider for hosting a needed application. By contracting with a service provider the user may interact with the application by using only a thin client rather than maintaining a thick client. The user rents an application from either the service provider or an independent application provider. If the user procures the application from an application provider, the application provider negotiates hosting terms with the service provider prior to installing the application into the service provider's warehouse. The application provider also checks that the services provided by the service provider meet the minimum requirements of the application. Once installed, the service provider may offer the application to other users along with services for the application. The user may procure additional services from the service provider for supporting the application. A user can then dynamically download the application &ldquo;on-demand&rdquo;.

System and method for automatically negotiating license agreements and installing arbitrary user-specified applications on application service providers

A system and method are disclosed, according to which, the responsiveness of client/server-based distributed web applications operating in an object-oriented environment may be improved by coordinating execution of cacheable entries among a group of web servers, operably coupled in a network. In an exemplary embodiment, entries are considered to be either commands or Java Server Pages (JSPs), and the system and method are implemented by defining a class of objects (i.e., CacheUnits) to manage the caching of entries. An entry must be executed before it can be stored in a cache. Since this is computationally costly, each cacheable entry has an associated coordinating CacheUnit, which sees to it that only one CacheUnit executes an entry. Once the entry has been executed, a copy of it resides in the cache of the coordinating CacheUnit, from which it can be accessed by other CacheUnits without having to re-execute it.

Distributed execution coordination for web caching with dynamic content

A method, operative at a web server, for generating an HTML table having dynamic data, wherein the table can be oriented in any horizontal or vertical orientation. The method preferably utilizes a table format page object to format the table. To facilitate selective rotation of the dynamic table, the method begins by associating together given attribute characteristics of each individual cell in the table. The page developer then sets a table style rotation property on the table format page object. In response to a client request, the table format page object is then instantiated with the dynamic data. The table style rotation property is applied to the table to control the table's orientation. The resulting table is then served back to the requesting client browser.

Method for rotating a dynamic HTML table

Different scripting languages may reside side-by-side or nested within each other on the same web page. Thus, a new author may add code to the page, and he or she is not tied to any given subset of languages supported by the web server. Multiple scripting languages are supported by identifying a start and an end of each scripting language code block authored into the web page markup language. When the web page is later compiled into an XML Document Object Model (DOM) tree, the routine examines the DOM to identify any nodes that identify a given code block. Upon encountering a node that identifies a given code block, the DOM is adjusted to account for the script code within the given code block.

Growing community of inventors

Austin, TX, United States of America

Michael Haden Conner