Patent Publication Number: US-7725500-B2

Title: Role based groups

Description:
TECHNICAL FIELD 
   Embodiments of the present invention relate to a Lightweight Directory Access Protocol (LDAP), and more specifically to methods of grouping entries. 
   BACKGROUND 
   Light Weight Directory Access Protocol (LDAP) has become very popular due to its efficient and fast data access. A large number of applications/services are currently being developed which use an LDAP directory as their centralized data repository. 
   The LDAP directory stores entries as a tree. Each entry may consist of one or more attribute names and attribute values. An entry may be uniquely identified by its distinguished name (DN) that may include a common name (cn) attribute of the entry and DN of a parent entry. 
   The contents of the entries are governed by an LDAP directory schema. The schema defines object classes, and each entry has an objectClass attribute containing named classes defined in the schema. The objectClass attribute may be multivalued, and contain the class “top” as well as some number of other classes. The schema definition for each class an entry belongs to defines what kind of object the entry may represent (e.g., a person, organization or domain). Membership in a particular class gives the entry the option of containing one set of attributes (optional attributes), and the obligation of containing another set of attributes (mandatory or required attributes). For example, an entry representing a person might belong to the class “person”. Membership in the “person” class would require the entry to contain the “sn” and “cn” attributes, and allow the entry also to contain “userPassword”, “telephoneNumber”, and other attributes. 
   A typical directory tree organizes entries hierarchically. This structure may not be optimal for short-lived or changing organizatios where groupins can be made based on an arbitrary user attribute. Furthermore, in a conventional directory system, a client application is tasked with determining the type of groupings desired and with providing the logic for search requests to achieve the desired results. This makes client software more complex, reduces performance and brings the potential for errors on the client, either accidental or deliberate. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which: 
       FIG. 1  illustrates a network architecture in which embodiments of the present invention may be implemented. 
       FIG. 2  illustrates a flow diagram of one embodiment of a method for managing role based groups in a directory server. 
       FIG. 3  illustrates a block diagram of an example of a role based group in a directory server. 
       FIG. 4  illustrates an example of a role definition in accordance with one embodiment. 
       FIG. 5  illustrates an example of a role based group definition in accordance with one embodiment 
       FIG. 6  illustrates a flow diagram of one embodiment of a method for enumerating entries that possess a role in a directory server. 
       FIG. 7  illustrates a block diagram of an exemplary computer system. 
   

   DETAILED DESCRIPTION 
   Described herein is a method and apparatus for managing role based groups in a directory server is described. Role based groups give membership of a group based on the entry possessing a specified role. This may be used with static groups, when an entry takes on a particular role, it is added to the group. When the role is removed, the entry is removed from the group. 
   In the following description, numerous details are 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 which follow are 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 following 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&#39;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, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus. 
   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-accessible storage medium includes any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer). For example, a machine-accessible storage medium includes read only memory (“ROM”); random access memory (“RAM”); magnetic disk storage media; optical storage media; flash memory devices; electrical, optical, acoustical or other form of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.); etc. 
   System Architecture 
     FIG. 1  illustrates an exemplary network architecture  100  in which embodiments of the present invention may operate. The network architecture  100  may include client devices (clients)  102 , an LDAP directory server  108  and a network  106 . The clients  102  may be, for example, personal computers (PCs), mobile phones, palm-sized computing devices, personal digital assistants (PDAs), etc. 
   The clients  102  are coupled to the LDAP directory server  108  via the network  106 , which may be a public network (e.g., Internet) or a private network (e.g., Ethernet or a local area Network (LAN)). The LDAP directory server  108  may contain a server front-end responsible for network communications, plugins for server functions (such as access control and replication), a basic directory tree containing server-related data, and a database back-end plugin responsible for managing the storage and retrieval of LDAP repository data. 
   In one embodiment, the clients  102  communicate with the LDAP directory server  108  via a web server (not shown). For example, the clients  102  may host web browsers that communicate with the web server using HTTP to request information. The web server may then communicate with the LDAP directory server  108  using LDAP to retrieve requested information from an LDAP repository  112 . Alternatively, the clients  102  may communicate directly with the LDAP directory server  108  using LDAP to request information stored in the LDAP repository  112 . 
   The network architecture  100  may also include one or more application servers  104  that hosts various applications requesting information from the LDAP directory server  108 . The application servers  104  operate as clients in communications with the LDAP directory server  112 . Similarly to the clients  102 , the application servers  104  may communicate with the LDAP directory server  112  directly or via a web server. 
   The LDAP repository  112  may be part of the LDAP directory server  108 , or it may reside externally (e.g., on a database server). Server  108  may be a single server or a cluster of servers. The LDAP repository  112  may contain a tree of data entries. The structure of the entries may be specified in the definition of the LDAP repository  112 . The definition of the LDAP repository  112  may be represented as a schema, a table or some other data structure, and may reside independently or inside the LDAP repository  112 . For example, the schema may be included in the LDAP repository  112  as a collection of LDAP repository entries rooted at the base DN cn=schema. 
   The schema may define object classes and attributes associated with each object class. Each entry in the LDAP repository has an objectClass attribute, containing one or more classes defined in the schema. The schema definition for each class an entry belongs to defines what kind of object the entry may represent (e.g., a person, organization or domain). 
   In one embodiment, the LDAP directory server  108  includes a role based group management module  110  that may be part of the LDAP directory server  108  or some other device and/or program, or be an independent module implemented in hardware, software or a combination thereof. 
   In one embodiment, the role based group management module  110  manages groups formed in the LDAP directory server  108 . Roles may be used to define certain common characteristics of members of a group. An entry may belong to a group if it possess a role within that group having a corresponding nsRole attribute. 
   In accordance with one embodiment, the role based group management module  110  defines a role attribute for one or more entries possessing a role. Role based group management module  110  also defines a group of entries in the directory server with a group role. The group role comprises one or more role attributes of one or more entries. The role attribute of the entries are queried to determine which entry possesses the group role. Role based group management module  110  provides entries that possess the group role to a client. 
   Overview of Static and Dynamic Groups 
   Groups are typically defined based on certain common characteristics of the members of the groups. A member can be included in a group if the member has an attribute of a specific type. Groups can be static or dynamic. A “static” group is one which where membership is specified by presence in a list. 
   A dynamic group is one where membership is inherent in some property of the entries. For example, a group containing a number of persons in a building might be “everyone on the third floor”, and this would be defined by a filter (query) against the directory for “floor=3”. As people are moved around the building, they may become part of the floor 3  group, or leave it, depending on their location. A key feature of dynamic groups is that they require no explicit maintenance—a static group which is intended to contain everyone on the third floor would need to be maintained, either manually or by a script and so would be either prone to error or not always up to date. There are also implementation efficiency issues relating to static versus dynamic groups. Thus, in a dynamic group, instead of looking at a group attribute to verify if a user possesses the group attribute, membership is determined by checking a user attribute, which can be specified arbitrarily. 
   Overview of Roles 
   A role is a comprehensive entry grouping mechanism, similar to the group concept. Role unifies the concepts of static and dynamic groupings, but transfers some of the complexity to the server side from the client side. While dynamic groups contemplate a hierarchical tree-like structure of an organization, roles assume that logically an organization structure could be substantially flat or hierarchical. 
   The directory system expresses the fact that an entry possess a role by placing the Distinguishing Name (DN) of the role in a computed and operational attribute, for example, the nsRole attribute. A computed attribute is one that is computed on the fly; it is a result of a computation. A computed attribute does not need to exist in a physical form; it can be stored temporarily in memory. An LDAP operational attribute is one that is available only if requested. The attribute nsRole is both computed and operational. 
   Each entry assigned to a role contains an attribute called nsRole, which is a computed attribute that specifies all of the roles to which an entry belongs. Roles enable applications to locate the roles of an entry, rather than select a group and browse the members list. Additionally, roles allow for support of generated attribute values, and directory server-performed membership verification for clients. By changing a role definition, a user can change an entire organization with ease. Moreover, roles can use the LDAP Virtual List View (VLV) control mechanism to enumerate the membership in a role. 
   A role is defined by a role definition entry. A role is uniquely identified by the distinguished name (DN) of its defining entry. Role definition entries are implemented as LDAP sub-entries. Thus, a role definition entry inherits sub-entry mechanism for scope of application to a directory information tree (DIT) subtree. An aspect of a role is that each role is defined by an entry stored in the DIT. Any client or program executing on the client with appropriate access privileges can discover, identify and examine any role definition. Any client or client program with an appropriate access privilege can add a new role definition, or modify existing role definitions. Further, role definitions can be replicated in a distributed environment. 
   Each role has entries called “members.” Members of a role are said to “possess” the role. Two varieties of roles are possible: simple roles, and complex roles. This classification, in one aspect, allows for implementation efficiency and supports some management functions. A client application can perform the following operations on roles: 
   (1) Enumerate the members of the role. 
   (2) Obtain an enumerated list of role members, which can be useful for resolving queries for group members quickly. 
   (3) Determine whether a given entry possesses a particular role. 
   (4) Determine the roles possessed by an entry, which can help a client-side application to determine whether the entry possesses the target role. 
   (5) Enumerate all the roles possessed by a given entry. 
   (6) Assign a particular role to a given entry. 
   (7) Remove a particular role from a given entry. 
   A client application can check role membership by searching the nsRole attribute, which is computed by the directory server and therefore is up-to-date. From the point of view of a client application, the method for checking membership is uniform and is performed on the server side. 
   Roles and Dynamic Groups 
   One of the differences between roles and dynamic groups is that dynamic groups impose a requirement on a directory client program to retrieve and correctly process the group definition. This makes client software more complex, reduces performance and brings the potential for errors on the client, either accidental or deliberate. Roles introduce an abstract membership test mechanism which allows responsibility for membership to rest with the directory server. The client only has to know the name of a role which is of interest to it, and how to test role membership in general. 
   Role is a more flexible entry grouping method than dynamic groups in part because a role allows a client to obtain the results normally obtained using static or dynamic groups without increased client complexity. A role can be configured in a number of ways to provide different results. 
   Role Operations 
   Given Arbitrary Roles and Entries, the Following Operations are Useful to Clients 
   1. Enumerate the members of a role (i.e., provide an answer to the question, “which entries have this role?”) It is also useful to be able to resolve this query in a reasonable time (significantly less than the time to find the members by brute force examination of all the entries). It is also useful to be able to retrieve the entries in a paged or browsing fashion, using the existing LDAP VLV mechanism. 
   2. Determine whether a given entry possesses a particular role. It is useful to be able to do this more efficiently than by determining all the roles possessed by the entry and then checking whether the target role is among that set of roles. 
   3. Enumerate all the roles possessed by a given entry. 
   4. Assign a particular role to a given entry. 
   5. Revoke a particular role from a given entry. 
   Role Based Groups 
   In accordance with one embodiment, a role based group gives membership of a group based on an entry possessing a specified role.  FIG. 2  illustrates a flow diagram of one embodiment of a method  200  for enumerating entries in a role based group in a directory server. The method may be performed by processing logic that may comprise hardware (e.g., circuitry, dedicated logic, programmable logic, microcode, etc.), software (such as instructions run on a processing device), or a combination thereof. In one embodiment, method  200  is performed by the role based group management module  110  of the LDAP directory server  108  of  FIG. 1 . 
   Referring to  FIG. 2 , at block  202 , a processing logic of the LDAP directory server  108  defines a role attribute for one or more entries in the directory server. In accordance with another embodiment, a role attribute may be defined for every entry in the directory server. At block  204 , a group may be defined with a group role. For example, a group may include the DN of one or more roles. At  206 , a query may be received to determined which entry possesses what role. At  208 , a query is performed to determine which entry possesses the group role. At  210 , a list of entries that possess the role attributes within the role (e.g. within the scope of the group role) is returned. 
     FIG. 3  illustrates a block diagram of a role based group management of an LDAP directory server in accordance with one embodiment. The distributed directory tree  300  includes a root entry  302  where a company named “Example.com” has a root entry of “dc=example, dc=com”. The root entry  302  has a first node  304 , and a second node  312 . The first node  304  and second node  312  include entries for the organization unit (ou). For example, the first node  304  defines an organization unit subtree for employees in the company (ou=people). Entries  306 ,  308 ,  310  corresponds to the individual employees working in the company. Each entry includes a Relative Distinguished Name (RDN) such as cn=michael smith in entry  306 . Furthermore, the entries include a role attribute. For example, entry  306  has a role attribute specifying an IT role. Entries  308 ,  310  have a role attribute specifying a HR role. 
   The second node  312  defines an organization unit subtree for groups in the company (ou=groups). The groups may be composed of IT group  314  and HR group  318 . The group are further defined by specified roles. For example, IT group  314  includes a DN of IT Role. So any entries having an IT role is also a member of the IT group  314 . Similarly, HR group  318  includes a DN of HR Role. So any entries having a HR role is also a member of the HR group  318 . The membership of each group are thus automatically populated. 
   Furthermore, if an entry loses its role, the role based group is automatically updated to reflect that change. So for example, if John Doe of entry  310  does not possess the HR Role, the entry  310  is also no longer a member of the HR role based group  318 . 
   If John Doe of entry  310  has been transferred from the HR department to the IT department, his entry  310  now possesses an IT role. Entry  310  is now a member of the IT role based group  314 . 
   In accordance with one embodiment, roles  320  may be defined in the directory tree. An example of a role definition  400  is illustrated in  FIG. 4 . An HR role  402  is defined to specify employees that work the HR department of a company. 
     FIG. 5  illustrates an example of a role based group definition  500  in accordance with one embodiment. In this example, an HR role based group  502  is defined so as to include entries having the HR role as members. An entry that possesses an HR role is now also a member of the HR role based group  502 . 
     FIG. 6  illustrates a flow diagram of one embodiment of a method for enumerating entries that possess a given role in a directory server. At  602 , for each entry within scope, the computed attribute nsRole is calculated. At  604 , the entry is examined to see if the role is present. At  606 , a list of entries that possess the role is generated. The list is thereafter returned to a client at  608 . The client receives the results of the search and enumerates all the entries returned. 
     FIG. 7  illustrates a diagrammatic representation of a machine in the exemplary form of a computer system  700  within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed. In alternative embodiments, the machine may be connected (e.g., networked) to other machines in a LAN, an intranet, an extranet, or the Internet. The machine may operate in the capacity of a server or a client machine in client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a server, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term “machine” shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein. 
   The exemplary computer system  700  includes a processing device  702 , a main memory  704  (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM), etc.), a static memory  706  (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage device  718 , which communicate with each other via a bus  730 . 
   Processing device  702  represents one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. More particularly, the processing device may be complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or processor implementing other instruction sets, or processors implementing a combination of instruction sets. Processing device  702  may also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. The processing device  702  is configured to execute the processing logic  726  for performing the operations and steps discussed herein. 
   The computer system  700  may further include a network interface device  708 . The computer system  700  also may include a video display unit  710  (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device  712  (e.g., a keyboard), a cursor control device  714  (e.g., a mouse), and a signal generation device  716  (e.g., a speaker). 
   The data storage device  718  may include a machine-accessible storage medium  730  on which is stored one or more sets of instructions (e.g., software  722 ) embodying any one or more of the methodologies or functions described herein. The software  722  may also reside, completely or at least partially, within the main memory  704  and/or within the processing device  702  during execution thereof by the computer system  700 , the main memory  704  and the processing device  702  also constituting machine-accessible storage media. The software  722  may further be transmitted or received over a network  720  via the network interface device  708 . 
   The machine-accessible storage medium  730  may also be used to store LDAP repository data entries  724 . LDAP repository data entries  724  may also be stored in other sections of computer system  700 , such as static memory  706 . 
   While the machine-accessible storage medium  730  is shown in an exemplary embodiment to be a single medium, the term “machine-accessible storage medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions. The term “machine-accessible storage medium” shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that cause the machine to perform any one or more of the methodologies of the present invention. The term “machine-accessible storage medium” shall accordingly be taken to include, but not be limited to, solid-state memories, optical and magnetic media, and carrier wave signals. 
   Thus, a method and apparatus for dynamically managing groups have been described. It is to be understood that the above description is intended to be illustrative, and not restrictive. Many other embodiments will be apparent to those of skill in the art upon reading and understanding the above description. The scope of the invention should, therefore, be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled.