|Número de publicación||US8090686 B2|
|Tipo de publicación||Concesión|
|Número de solicitud||US 11/706,011|
|Fecha de publicación||3 Ene 2012|
|Fecha de prioridad||13 Feb 2007|
|También publicado como||US8600933, US20080195616, US20120095960|
|Número de publicación||11706011, 706011, US 8090686 B2, US 8090686B2, US-B2-8090686, US8090686 B2, US8090686B2|
|Inventores||Peter A. Rowley|
|Cesionario original||Red Hat, Inc.|
|Exportar cita||BiBTeX, EndNote, RefMan|
|Citas de patentes (41), Otras citas (18), Citada por (2), Clasificaciones (7), Eventos legales (2)|
|Enlaces externos: USPTO, Cesión de USPTO, Espacenet|
The invention relates to hierarchical database operations. In particular, the invention provides mechanisms to extend the capabilities of a Lightweight Directory Access Protocol (“LDAP”) database.
The Lightweight Directory Access Protocol (“LDAP”) is a standard computer networking protocol for querying and modifying entries in a database. The basic protocol is defined in a group of Internet Engineering Task Force (“IETF”) Request for Comments (“RFC”) documents; various aspects of the current version of the protocol (version 3) are described in RFCs listed in the “LDAP Technical Specification Road Map” (RFC4510, published June 2006). The databases reachable through LDAP may contain any sort of data, but most commonly contain identity, contact and authorization information for people and organizations.
LDAP presents a hierarchical view of the data in a database. Records are presented as a tree of entries, each entry identified uniquely within the hierarchy by its Distinguished Name (“DN”). Entries contain one or more attributes, which consist of an attribute description (an attribute type with zero or more options), plus one or more values of the attribute. For example, an attribute type might be “givenName”, and its value might be a text string that is the given name of a person described by the record.
Access to data in an IDAP database is provided by an IDAP server, which responds to commands from an IDAP client. For example, a client may create a new entry, delete an entry, rename an entry, modify an entry, or (most commonly) retrieve the attributes in an entry.
The IDAP standards specify certain properties that compliant servers (and their underlying databases) must have. These properties are known by the acronym ACID: Atomicity (updates must happen in an all-or-none fashion); Consistency (updates must begin at a consistent state and leave the updated database in a new consistent state); Isolation (no part of a multi-part update is visible to other clients until the complete update is performed); and Durability (successful updates will not be lost).
These properties are relatively easy to achieve in a single-server IDAP implementation, but a large network with many clients may generate enough IDAP operations to overwhelm a single server. Additional IDAP service capacity can be added with slave servers that respond to read-only (query) requests, while a master server handles all updates. However, some environments perform enough updates to overwhelm a single master server, and other environments (e.& geographically distributed networks) may operate more efficiently with a nearby master server. Unfortunately, it can be difficult for an LDAP service with multiple master servers to guarantee atomicity, consistency, isolation and durability of updates while maintaining the protocol's favorable speed characteristics. Operational techniques to coordinate multiple master servers may be of value.
Embodiments of the invention are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings, in which like references indicate similar elements. It should be noted that references to “an” or “one” embodiment in this disclosure are not necessarily to the same embodiment, and such references mean “at least one.”
Embodiments of the invention implement a recursive lock-and-propagate protocol to coordinate independent master database servers. Each master server maintains a local copy of the database, and coordinates its operations with other masters to ensure that data changes made by one master are distributed or propagated to the other masters. A specific application of the protocol, to permit unique attributes to be reliably created in a multi-master database network, is also described.
The master servers shown in
Next, the first server tests the requested operation on its local copy of the database (230). For example, if the client has requested a search for a record containing a certain attribute/value combination, the server confirms that such a record exists. If the client has requested to delete a particular record, the server checks to see that the record exists and can be deleted. If the test fails (240), an “unsuccessful” response is returned (280).
If the operation would succeed locally, the first server propagates the request to each master server that is directly connected to the first server (250). The propagated request (including the flag or other indicator to activate recursive lock-and-propagate operations) includes a list of servers that will be, or already have been, queried (the precise makeup of the list is discussed in further detail below).
When a server receives a propagated request (251), it acquires a local lock of its own (252), tests the request locally (253) and propagates the request (including the flag or other indicator, and the list of already-visited servers) to any of its directly-connected peers that have not yet been visited (254). Responses from the directly-connected peers are collected (255), then the local lock is released (256) and a response is sent to the querying peer (257).
If a queried machine is successful in acquiring the local lock and would be able to perform the requested operation, it will report success. Otherwise, it will report failure. If any query of a directly-connected server fails, any remaining directly-connected servers need not be queried; the server can report the failure to the peer server (or ultimately, the client) that sent the request. A response will also include the list of servers visited during the preparation of the response, and the querying server will add those servers to its “already visited” list so that they will not be visited again.
If a client issued a search request to server 120 in
The recursive locking and operation test requests include a list of already-visited servers, and may include a list of servers that are scheduled to be visited. The list is to prevent a server from being visited again and again, since each server need only be visited once during each network-wide recursive search. The policy for listing servers can affect the propagation of the recursive operation test through the network. For example, if only actually-visited servers are listed, the overall search may be narrower and deeper. If to-be-visited servers are also listed, the overall search may be broader and shallower. An embodiment may select one policy or another to suit the topology and data communication capabilities of the network.
The recursive locking and operation propagation algorithm described above permits a client to ensure that all the master servers concur on the value of an item in the database (i.e. that any change made at one master server has been correctly propagated to other master servers in the network), and furthermore permits the atomicity, consistency and isolation guarantees of a single server to be extended across a network of servers, as explained in connection with the application described below. Note that there may be a transitional period after a change is made at one master server before the same data has been replicated at all the other servers. In fact, a client may be surprised to be unable to read its own writes, if its read is serviced by a server to which the modified data has not yet propagated. However, the recursive locking and operation propagation algorithm ensures that operations predicated on outdated data that may be attempted at a remote (not-yet-updated) master server will fail during the recursive operation testing process when they are tested at the server where the earlier update was made. A benefit of the algorithm described is simplicity relative to other methods of maintaining a consistent distributed database (e.g. a two-phase commit system where all servers are placed in a ready-to-commit state, then changes are committed everywhere at once).
An embodiment of the invention can be implemented in a network of Lightweight Directory Access Protocol (“LDAP”) servers that cooperate to maintain a consistent distributed database. Although the LDAP standards do not define a recursive locking and operation propagation mechanism as described above, such a mechanism can be added to an LDAP server and activated by including a flag called a “control” with a client's LDAP operation request. (The same control may be used for server-to-server queries; it is not necessary to implement a different or non-standard mechanism for the recursive searches that one server sends to its directly-connected peers.) The control directs the server to process the search in a particular way; in this case, the control calls for the server to acquire a local lock, then propagate the operation to its directly-connected peers.
The data maintained by the network of IDAP servers may include attributes that must be unique and consistent. For example, some IDAP entries may refer to computer users, and each computer user may require a unique user identification number (“UID”). When a new user entry is added, a new UID is selected. The UID must be different from others previously used, but the system must also prevent two new users, whose entries are added at different master servers in the network, from selecting the same new, previously unused UID.
An IDAP client (i.e. a user management program that is to create the new user entry) retrieves the next UID from an attribute of an entry maintained by an IDAP server (300). This query can be serviced by any master server or slave server in the network. Next, a two-operation “search and modify” request is transmitted to a master server (310). The “search” operation matches the NextUID attribute and the previously-determined value, and the “modify” operation changes NextUID's value to a new, unused UID (for example, to the next successive integer). Because of LDAP's ACID guarantees, both of these operations will succeed, or neither will. Thus, as to the master server that receives the request, the old value of NextUID may be allocated to the user being created, and a new value of NextUID is made available for another new user. However, to ensure that the newly-allocated UID was not previously assigned to another user through operations occurring at a different master server, the “search” operation includes the control that triggers the recursive lock and search algorithm of an embodiment of the invention.
When the master server receives the search-and-modify request with the triggering control, it acquires a local lock (320) and propagates the search to its directly-connected peers (330). The search travels from master to directly-connected master, as described above (340), and eventually a consolidated response is received (350). If the recursive search was successful (360), the modification operation is performed (370) and an IDAP “success” response is returned to the client (380). If the recursive search was unsuccessful (365), a “failure” response is returned to the client (390).
The method outlined in
A variable backoff-and-retry algorithm may reduce the number of contention-failures when two or more clients attempt to add a series of database entries including unique elements. Also, a client with several entries to add may be able to allocate a corresponding number of unique elements all at once, then assign them to the new entries one-at-a-time, without further affecting other clients that are also adding entries.
It is appreciated that a failure during the recursive lock and search procedure may indicate that some data has not propagated throughout the distributed database, and may be used as a trigger to launch an update process. This can support a “lazy” replication paradigm: new and modified data may normally be sent to other master servers on a fixed schedule or when network and processing resources are available, but if a recursive lock and search fails, data corresponding to the failing search may be sent to peer servers immediately. This can help ensure that important or frequently-referenced data is kept more closely synchronized than other, less-frequently referenced information.
The “local lock” used in the recursive lock and search procedure may be a server-wide lock (i.e. only one recursive lock and search may be operative at any time), or it may be connected with an entry or attribute located through the search. The latter arrangement may permit many concurrent lock/search operations, as long as they concern different entries or attributes. Because of the way the search proceeds (each server in the network is only visited once), deadlock is impossible during a single search. However, deadlock scenarios are possible when two servers try to execute recursive queries at the same time. To avoid these deadlocks, local locks should be constructed so that they do not block: a lock request should either succeed immediately or fail immediately (if the lock is already taken). A lock failure propagates back to the original master, which may release its own local lock and delay briefly before trying again.
If a server is unable to propagate a recursive search to one of its directly-connected peers (e.g. the server is offline or down), it should fail in the normal way. The originating server must refuse any modify operation connected with a failed recursive search.
Although the preceding examples have discussed the specific scenario of selecting a unique integer for a UID, those of ordinary skill will recognize that the techniques can be used to create or choose any type of value that must be unique within the distributed database. Group Ids (“GIDs”), usernames, and other unique attributes can be created without risk of duplication.
Some embodiments of the invention can operate exclusively within the server (and in cooperating master servers that also implement an embodiment of the invention), without requiring any special behavior on the part of the client to ensure attribute uniqueness.
First, a client submits an operation (e.g. an IDAP operation) to a master server to modify an attribute or create a new attribute (500). The attribute is marked in the database as “unique,” and the server is configured to perform the following operations when the attribute is created or modified. (“Uniqueness” is a common and useful property for the server to check and enforce, but other properties, such as equivalence to another attribute or a predetermined relationship among a group of attributes, could be substituted.)
The server acquires a local lock (510), tests the operation locally (520), and if the test succeeds (530), propagates the operation to its directly-connected peers (540). The peers, operating as described above, recursively lock and propagate the operation throughout the network (550), finally returning a pass/fail indication (560) to the first server. If the operation would succeed everywhere (570), the first server performs the operation (580) and (either way) returns a success/fail indicator to the client (590). If the client's request fails, it may retry the request after a brief delay on the assumption that the failure was a result of transient connectivity problems, conflicting operations submitted elsewhere, or updated information elsewhere in the network that had not yet become available to the client.
Testing the operation at a server may include verifying that the operation, if completed, would not create a record containing a duplicate of data that was supposed to be unique, or that the operation would maintain another implementation-invariant condition (i.e. one attribute that is always to be equal to another, or always to have a predetermined relationship to another value or group of values).
An embodiment of the invention may be a machine-readable medium having stored thereon data and instructions to cause a programmable processor to perform operations as described above. In other embodiments, the operations might be performed by specific hardware components that contain hardwired logic. Those operations might alternatively be performed by any combination of programmed computer components and custom hardware components.
Instructions for a programmable processor may be stored in a form that is directly executable by the processor (“object” or “executable” form), or the instructions may be stored in a human-readable text form called “source code” that can be automatically processed by a development tool commonly known as a “compiler” to produce executable code. Instructions may also be specified as a difference or “delta” from a predetermined version of a basic source code. The delta (also called a “patch”) can be used to prepare instructions to implement an embodiment of the invention, starting with a commonly-available source code package that does not contain an embodiment.
In the preceding description, numerous details were set forth. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In some instances, well-known structures and devices are shown in block diagram form, rather than in detail, in order to avoid obscuring the present invention.
Some portions of the detailed descriptions were presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the preceding discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.
The present invention also relates to apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, compact disc read-only memory (“CD-ROM”), and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), eraseable, programmable read-only memories (“EPROMs”), electrically-eraseable read-only memories (“EEPROMs”), magnetic or optical cards, or any type of media suitable for storing electronic instructions.
The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. Various general purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatus to perform the required method steps. The required structure for a variety of these systems will appear from the description below. In addition, the present invention is not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the invention as described herein.
A machine-readable medium includes any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer). For example, a machine-readable medium includes a machine readable storage medium (e.g., read only memory (“ROM”), random access memory (“RAM”), magnetic disk storage media, optical storage media, flash memory devices, etc.) etc.
The applications of the present invention have been described largely by reference to specific examples and in terms of particular allocations of functionality to certain hardware and/or software components. However, those of skill in the art will recognize that linked IDAP attributes can also be implemented by software and hardware that distribute the functions of embodiments of this invention differently than herein described. Such variations and implementations are understood to be captured according to the following claims.
|Patente citada||Fecha de presentación||Fecha de publicación||Solicitante||Título|
|US5799141 *||9 Jun 1995||25 Ago 1998||Qualix Group, Inc.||Real-time data protection system and method|
|US6192362||15 Dic 1997||20 Feb 2001||International Business Machines Corporation||System and method for creating a search form for accessing directory information|
|US6339827||12 Nov 1997||15 Ene 2002||International Business Machines Corporation||Method for securing sensitive data in a LDAP directory service utilizing a client and/or server control|
|US6347312 *||5 Nov 1998||12 Feb 2002||International Business Machines Corporation||Lightweight directory access protocol (LDAP) directory server cache mechanism and method|
|US6418441||24 Jul 2000||9 Jul 2002||Charles G. Call||Methods and apparatus for disseminating product information via the internet using universal product codes|
|US6470354 *||5 Ago 1999||22 Oct 2002||International Business Machines Corporation||Implementing persistent object services (POS) on top of a relational database|
|US6651070||29 Jun 2000||18 Nov 2003||Hitachi, Ltd.||Client/server database system|
|US6715128||24 Nov 1999||30 Mar 2004||Hitachi, Ltd.||Method for converting directory data, and program and device therefor|
|US6947953||18 May 2001||20 Sep 2005||The Board Of Trustees Of The Leland Stanford Junior University||Internet-linked system for directory protocol based data storage, retrieval and analysis|
|US6970873||2 Ago 2001||29 Nov 2005||Sun Microsystems, Inc.||Configurable mechanism and abstract API model for directory operations|
|US7043472||11 Oct 2002||9 May 2006||International Business Machines Corporation||File system with access and retrieval of XML documents|
|US7209970||19 Sep 2000||24 Abr 2007||Sprint Spectrum L.P.||Authentication, application-authorization, and user profiling using dynamic directory services|
|US7444594||14 Abr 2004||28 Oct 2008||Microsoft Corporation||Mediating conflicts in computer user's context data|
|US20030037044||29 May 2001||20 Feb 2003||David Boreham||Enumerated roles in a directory system|
|US20030055917||29 May 2001||20 Mar 2003||Boreham David W.||Method and system for determining a directory entry's class of service in an indirect manner|
|US20030061347||29 May 2001||27 Mar 2003||David Boreham||Method and system for determining a directory entry's class of service by pointing to a single template entry|
|US20030078937||29 May 2001||24 Abr 2003||David Boreham||Method and system for nesting roles in a directory system|
|US20030078995||29 May 2001||24 Abr 2003||David Boreham||Method and system for determining a directory entry's class of service based on the value of a specifier in the entry|
|US20030084069||29 May 2001||1 May 2003||David Boreham||Method and system for creating and utilizing managed roles in a directory system|
|US20030088656||2 Nov 2001||8 May 2003||Wahl Mark F.||Directory server software architecture|
|US20030088678||6 Nov 2001||8 May 2003||Boreham David W.||Virtual attribute service in a directory server|
|US20030105733||29 May 2001||5 Jun 2003||David Boreham||Method and system for incorporating filtered roles in a directory system|
|US20030105742||29 May 2001||5 Jun 2003||David Boreham||Method and system for grouping entries in a directory server by group memberships defined by roles|
|US20030115196||29 May 2001||19 Jun 2003||David Boreham||Method and system for sharing entry attributes in a directory server using class of service|
|US20030135491||16 Ene 2002||17 Jul 2003||Pete Rowley||Directory server views|
|US20030191751||9 Ene 2003||9 Oct 2003||Kumar Vora||Method and apparatus for implementing a corporate directory and service center|
|US20040006557||8 Jul 2002||8 Ene 2004||Baker Nathan B.||Technique for effective management of directory information|
|US20040267670||28 Jun 2004||30 Dic 2004||Wrq, Inc.||Utilizing LDAP directories for application access control and personalization|
|US20050021498||12 Jul 2004||27 Ene 2005||David Boreham||Method and system for creating and utilizing managed roles in a directory system|
|US20050060646||29 Oct 2004||17 Mar 2005||Microsoft Corporation||Method for redirecting the source of a data object displayed in an HTML document|
|US20050080792||9 Oct 2003||14 Abr 2005||Ghatare Sanjay P.||Support for RDBMS in LDAP system|
|US20050160090||24 Feb 2005||21 Jul 2005||Microsoft Corporation||Method and system for accessing database objects in polyarchical relationships using data path expressions|
|US20050171958||8 Abr 2002||4 Ago 2005||Qingwen Cheng||Method and system for implementing policies, resources and privileges for using services in LDAP|
|US20050203897||19 Abr 2005||15 Sep 2005||Olga Kapitskaia||Method for using query templates in directory caches|
|US20050216485||25 Mar 2004||29 Sep 2005||International Business Machines Corporation||Real-time attribute processor and syntax schema for directory access protocol services|
|US20050228794||29 Mar 2005||13 Oct 2005||Navas Julio C||Method and apparatus for virtual content access systems built on a content routing network|
|US20060122963 *||8 Nov 2004||8 Jun 2006||Oracle International Corporation||System and method for performing a data uniqueness check in a sorted data set|
|US20070016575||14 Dic 2005||18 Ene 2007||Microsoft Corporation||Consolidating local and remote taxonomies|
|US20070149190||16 Dic 2004||28 Jun 2007||Kabushiki Kaisha Kenwood||Roaming system, mobile communication system, and mobile communication control method|
|US20070240050||10 Abr 2006||11 Oct 2007||Graphwise, Llc||System and method for presenting to a user a preferred graphical representation of tabular data|
|US20080114770||14 Nov 2006||15 May 2008||Jinfang Chen||Attribute level federation from multiple data sources|
|1||Office Action mailed Apr. 27, 2009, for U.S. Appl. No. 11/656,579.|
|2||Office Action mailed Apr. 28, 2010, for U.S. Appl. No. 11/656,579.|
|3||Office Action mailed Apr. 30, 2009, for U.S. Appl. No. 11/607,559.|
|4||Office Action mailed Aug. 18, 2010, for U.S. Appl. No. 11/703,310.|
|5||Office Action mailed Dec. 18, 2008, for U.S. Appl. No. 11/703,310.|
|6||Office Action mailed Dec. 9, 2008, for U.S. Appl. No. 11/656,579.|
|7||Office Action mailed Jun. 18, 2010, for U.S. Appl. No. 11/607,559.|
|8||Office Action mailed Mar. 16, 2010, for U.S. Appl. No. 11/607,559.|
|9||Office Action mailed Mar. 2, 2010, for U.S. Appl. No. 11/703,310.|
|10||Office Action mailed Nov. 12, 2008 for U.S. Appl. No. 11/607,559.|
|11||Office Action mailed Nov. 19, 2010, for U.S. Appl. No. 11/607,559.|
|12||Office Action mailed Oct. 28, 2009, for U.S. Appl. No. 11/703,310.|
|13||Office Action mailed Oct. 5, 2009, for U.S. Appl. No. 11/607,559.|
|14||Office Action mailed Sep. 24, 2009, for U.S. Appl. No. 11/656,579.|
|15||*||Randy Urbano, Oracle (r) Database Advanced Replication, Dec. 2003, 10g Release 1 (10.1), Oracle Corporation.|
|16||Red Hat Notice of Allowance for U.S. Appl. No. 11/607,559 (5220P023) mailed Jun. 17, 2011.|
|17||Wahl, M., Netowrk Working Group, A summary of the X.500(96) User Schema for use with LDAPv3, Critical Angle Inc., Dec. 1997, 15 pages.|
|18||Zeilenga, K., Network Working Group, Lightweight Directory Access Protocol (LDAP): Technical Spericiation Road Map, OpenLDAP Foundation, Jun. 2006, 8 pages.|
|Patente citante||Fecha de presentación||Fecha de publicación||Solicitante||Título|
|US9020828 *||17 Jun 2008||28 Abr 2015||Siemens Aktiengesellschaft||Referencing of patient-related information in a distributed medical system|
|US20090006134 *||17 Jun 2008||1 Ene 2009||Georg Heidenreich||Referencing of patient-related information in a distributed medical system|
|Clasificación de EE.UU.||707/613, 707/623|
|Clasificación internacional||G06F17/00, G06F7/00|
|Clasificación cooperativa||G06F17/30575, G06F17/30362|
|13 Feb 2007||AS||Assignment|
Owner name: RED HAT, INC., NORTH CAROLINA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:ROWLEY, PETER A.;REEL/FRAME:018962/0146
Effective date: 20070212
|17 Jun 2015||FPAY||Fee payment|
Year of fee payment: 4