CA2226360C - Method and apparatus for managing applications in a network - Google Patents

Abstract

A method and apparatus for management of application programs in a computer network are disclosed. A modified hierarchical database which includes application objects that represent applications and their execution environments is utilized. Administrator tools support the creation, deletion, and modification of application objects. Each application object includes the location of an executable code for a given application, an icon, a working directory name, drive mappings, printer port captures, command line parameters, and similar information. An application launcher queries the database and updates a list of available applications which is kept in the user's desktop. The launcher automatically launches specified applications when a user runs the launcher. The launcher also uses the information in the application object to set up resources needed by the application, to create a process that executes the application, and to clean up after the application terminates. Resource setup involves mapping drives and capturing printer ports as needed. The database, the launcher, and the administrator tools allow consistent tracking and use of information about application programs and their execution environments in the network.

Description

CA 02226360 l998-0l-06 W O 97/03399 ~CTrUS96/11263 METHOD AND APPARATUS FOR MANAGING
APPLICATIONS IN A NETWORK

FIELD OF THE INVENTION
The present invention relates to the management of application programs in a computer ~ 5 network, and more particularly to a method and d~p~lld~U~ for m~n~in~ applications in a multi-server network through the use of application objects in a hierarchical directory services t~h~e.

TECHNICAL BACKGROUND OF THE INVENTION
It is not llmlcn~l for a modern CO~ uL~ network to contain several server m~rhines as well as numerous client m~hines The servers typically provide file access, printer access, and other services to users who are stationed at the client m~hines. Some large networks contain dozens of servers and hundreds of clients. The person responsible for ~flmini~tering the network is known as the "network ~lmini~trator" or "~-lminictrator." Persons who use the network are known as "users." Administrators are also users.
A wide variety of application programs such as word processors, spre~ heets, database managers, program development tools, and the like (collectively, "applications") are typically found on one or more servers in the network. However, applications are often under-ntili~
Sometimes a potential user does not know whether a particular application would be helpful 20 because the user is lmf~mili~r with that application. Sometimes applications could be made available to those who would benefit from their use, but the nece~ry file access rights and execution environment have not been provided by the ~-lmini~trator. Sometimes a user who is ~ f~mili~r with an application does not realize that the application was recently placed on the network.

CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263Even if a user wishes to execute a particular application and believes that the executable code for that application exists somewhere on the network, the user still must locate and access that code in order to utilize the application. Unfortunately, the executable codes for applications are often scattered amongst many servers, thereby m~kin~ it difficult at times even for admini-s strators to locate particular executable codes. The situation is much worse for users who arennf~mili~r with the technical aspects of network olgi1lli7i1lion and ~Amini~tration~ Because such users are often unable to locate the desired executable codes and/or create a~r~,~.iate execution environments, they are unnecessarily prevented from using helpful applications.
More experienced users often m~nn~lly m~int~in records of the locations of certain 10 application executables, but this approach has several drawbacks. Often, a user does not initially know where a particular executable is located. Sç~nning the directories of numerous servers to locate an executable is a possible approach. But c- ~nning directories is potentially very time-consuming, particularly if it becomes necessary to attach the user's client machine to numerous servers to access their directories. Asking a network ~clmini~trator where to find a particular 15 program is also possible, but repeatedly answering such queries from many users takes signifi-cant time away from other tasks that require the ~lmini~trator's attention and expertise. Keeping manual records requires maintenance each time an executable's location is changed, thereby cutting into the time the user and/or ~flmini~trator could be devoting to other duties.
In addition to an executable code, other resources are typically required by an application 20 before it can successfully execute. In some cases it is necessary to map drives, to capture printer ports, or to specify a working directory for files which will hold intermediate or final data produced by the application. Access to files or directories may require that the user have read~
write, or other rights. In some network environments a particular application will run more efficiently or effectively if its execution is preceded by a set of comm~ntl~ found in a startup W O 97/03399 PCTtUS96tll263 script, or if its execution is followed by a set of commHn~l~ found in a shutdown script. Many applications allow or require parameters to be passed to the application's executable code on the same command line which invokes that code.
Thus, in addition to m~ H;. .i~ ~g the location of the executable code, users and ~1mini~trators who m~nnH11y mHintHin records regarding applications often find it helpful or necessary to m~int~in additional information regarding the execution ~l~vh~ llent of each application, such as drive mappings, printer port requirements, working directory names, access rights, scripts, and command line parameters. In practice this additional information is at least as widely scattered as the executable codes and is often stored in different formats by dir~l~,nt lO persons. Many users lack the expertise, the time, or both, to mHm1H11y manage such information.
After an application has been on the network for some time, it is not unusual for incon~i~ten versions of execution environment information to be found in different formats on different machines throughout the network.
Thus, it would be an advancement in the art to provide a computer-implemented method and ~paldLus for consistently tracking the location of application program executable codes in a network.
It would also be an advancement to provide such a method and ~ald~us which reduce the ~-lmini~trative effort associated with changes in the location of application program executable codes or changes in other information needed to execute an application.
It would be a further advancement to provide such a method and a~l~dlus for consistently tracking and employing additional information used to execute an application program, such as drive mappings, printer port requirements, working directory names, scripts, and/or command line parameters.

W O 97/03399 PCT~US96/11263 Such a method and a~pald~us are disclosed and claimed herein.

BRIEF SUMMARY OF THE INVENTION
The present invention provides a method and a~paldlu~ for centrally m~n~ging applica-5 tion programs in a co~ u~el network. One aspect of the present invention provides a modified.l~t~h~e schema. The cl~t~h~e schema defines what type of resources can be represented in the t~h~e The ~1?tslh~e provides network ~tlmini~trators with an efficient and effective way to cletermine what resources are available on the network, to provide fault-tolerance by making resources available even if a server on the network becomes unavailable, and to control the 0 access of particular network users or groups of users to particular network resources.
The resources represented in the modified ~l~t~b~e include application programs, such as word processors and spreadsheets, that reside on the network. The modifications to the schema provided by the present invention support the creation, deletion, and alteration of application objects in the database. In one embodiment, ~lnnini~trative routines for m~n~gin~ application 5 objects are provided through a "snap-in" module that extends the f~mili~r NWAdmin tool presently used on Novell NetWare(~ networks.
Each application object represents one application program and its execution environment. Thus, in one embodiment each application object includes the location of at least one executable code for the application in question, a brief name which textually identifies the 20 application, an icon which graphically identifies the application, the location of the application's working directory, the drive mappings and printer port captures needed by the application, and the command line parameters (if any) that should be passed to the application when it begins execution. Alternative embodiments of application objects include additional useful information such as a brief textual description ("blurb") describing the application to potential new users, a W O 97/03399 PCT~US96/11263 list of other users who can be contacted to answer questions about the application, licensing information, and scripts to run before and/or after execution of the application.
Collecting such information about each application into one application object in the t~b~ee assists greatly in preventing the creation or use of incon.ei.etent or obsolete information 5 about the application. Moreover, application objects receive t_e beneficial characteristics of the rlz~t:~bz~ee such as hierarchical org~ni7~tion~ access control, replication of ~l~t~h~ee objects to provide fault-tolerance, and access through f~mili~r interface tools.
The present invention also provides an application l;~llncher. In one embodiment, the application l~llncher allows a user to browse through the application objects which represent the 10 applications available to that user and to view the information ~ ly stored in the objects.
The l~llnch~r also automatically l~nnch~s specified "auto start" applications when a user runs the l~lmçher. In addition, the l~llncher updates a list of available applications that is associated with the user's desktop by querying the database. The launcher's update capability relieves minietrators of the need to manually update each user's desktop when a new application is s added to the network or an established application is moved.
When it is requested to launch an application, the l~llncher uses the information in the application's fl~t~h~ee object to setup execution environment resources needed by the application, to then create a process which executes the application, and to finally clean up after the application t~rmin~tPe Resource setup typically involves mapping drives and capturing 20 printer ports as needed; setup may also involve running a startup script. After the application termin~tes7 the launcher cleans up by unmapping drives, releasing captured ports, and detaching from servers as needed. Cleaning up also includes running a shutdown script if one is provided.
Thus, the present invention provides a computer-implemented method and apparatus for coneiet.?ntly tracking and employing information about application programs and their execution W O 97/03399 PCT~US96/11263 environments in a network. Consistency is achieved by gathering the information into a central ~l~t~h~ec which is acce~e-l through specified ~imini~trator tools and user interf~re~. Database updates are readily performed with the ~lmini.etrator tools or by the application l~llnch~r, thereby reducing the effort associated with changes in the location of executables or in the other 5 illfol~ ion needed to execute an application.
The features and advantages of the present invention will become more fully a~ nt through the following description and appended claims taken in conjunction with the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS
To illustrate the manner in which the advantages and features of the invention are obtained, a more particular description of the invention summz~ri7~1 above will be rendered by reference to the appended drawings. Understanding that these drawings only provide selected embo~liment~ of the invention and are not therefore to be considered limiting of its scope, the 15 invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:
Figure 1 is a diagram illustrating a computer network.
Figure 2 is a diagram illustrating components of the computer network of Figure 1 together with ~imini~trator tools and user tools employed in conjunction with the computer 20 network.
Figure 3 is a flowchart illustrating an event-driven embodiment of application management routines according to the present invention for supplementing the ~llmini~trator tools and the network shown in Figure 2.

W O 97/03399 PCTrUS96/11263 Figure 4 is a flowchart illustrating an alternative comm~nll-driven embodiment of the application management routines of the present invention.
Figure 5 is a flowchart further illuskating an application management routine for modifying a network ~l~t~ e schema according to the present invention.
s Figure 6 is a flowchart further illuskating atkibute definition and addition steps of the routine shown in Figure 5.
Figure 7 is a flowchart further illuskating class definition and addition steps of the routine shown in Figure 5.
Figure 8 is a flowchart further illuskating an application l~llncher according to the lo present invention.
Figure 9 is a flowchart further illuskating an application l~llnchin~ step shown in Figure 8.
Figure 10 is a flowchart further illuskating a resource setup step shown in Figure 9.
Figure 11 is a flowchart further illustrating drive mapping, port capturing, and server attaching steps shown in Figure 10.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
The present invention relates to a method and ~aldLIls for m~n~ging application programs in a computer network that includes h~.lw~;, software, and data components. In describing the present invention and its context, the terms "program," "module," "routine,"
"subroutine," "function," and "procedure" are used interchangeably because the technical differences between these software components do not alter the scope of the present invention.
The terms "object code," "executable code," and "executable" are likewise used interchangeably.
As used herein, the term "embodiment" encompac.~es specific methods, specific ap~aldL~ls, and specific program storage devices or articles of m~nllf~ ture which are provided by the present invention.
Reference is now made to the figures wherein like parts are referred to by like numerals.
One of the many n~Lw~ lhs suited for use with the present invention is indicated generally at 10 in Figure 1. In one emboflimPnt the network 10 includes Novell NetWare~) software, version 4.x (NetWare is a registered tr~ onn~rk of Novell, Inc.). The illustrated network 10 includes several connected local networks 12. Each local network 12 includes a file server 14 and one or more user stations 16. A printer 18 and an array of disks 20 are also ~ltt~ to the network 10.
Although a particular network 10 is shown, the present invention is also useful in a variety of lo other n~lwolh~ which are known to one of skill in the art.
With reference to Figures 1 and 2, ~rimini~tration and use of the network 10 aresupported by network software and hardware elements, by ~tinnini~trator tools, and bv user tools.
Figure 2 illustrates the relationship between these components. The network 10 includes a variety of resources 22, such as the printers 18, the disk array 20 and other storage devices, and ls applications 23 and data that are stored on one or more of the file servers 14 and user stations 16.
The network resources 22 are ~irnini~t~red through certain directory services 24. The precise nature of the directory services 24 varies among dirre~ networks but in general the directory services 24 ~tirnini~ter both the location of the resources 22 and the rights of network users to use the resources 22.
In a presently ~l~rc~ d embodiment the directory services 24 include services provided by NetWare Directory Services ("NDS") software 26 that is commercially available from Novell, Inc. of Orem, Utah (NetWare Directory Services is a tr~iern~rk of Novell, Inc.). The directory services 24 component includes a schema 28. Prior to the present invention the CA 02226360 l998-0l-06 W O 97/03399 PCTrUS96/11263 schema 28 was a default schema 30 that did not support application objects. The schema 28 of the present invention is an extencle~l schema 32 which does support application objects.
The sc.hem~ 28,30, and 32 each include a set of "attribute syntax" definitions, a set of "attribute" definitions, and a set of "object class" (also known as "class") definitions. The NDS
s software 26 and the default NDS schema 30 are described in chapters 6 through 8 of NetWare 4 for Professionals by Bierer et al. ("Bierer"), which are incorporated herein by reference. Certain ideas exrl~in~l in Bierer are repeated herein. The terms "attribute" and "property" are used interchangeably in Bierer and herein, as are the terms "attribute syntax" and "~lop~lLy syntax."
Differences between the default schema 30 and the exten-le-l schema 32 of the present invention 0 are described in detail below after a general discussion of the generic schema 28.
Each attribute syntax in the schema 28 is specified by an attribute syntax name and the kind and/or range of values that can be assigned to attributes of the given attribute syntax type.
Attribute syntaxes thus correspond roughly to data types such as integer, float, string, or Boolean in conventional progr~rnming languages.
Each attribute in the schema 28 has certain information associated with it. Each attribute has an attribute name and an attribute syntax type. The attribute name identifies the attribute, while the attribute syntax limits the values that are assurned by the attribute. For instance, the default schema 30 includes an attribute of syntax type integer having the name "supported connections" which specifies the number of concurrent connections a file server allows.
Each attribute may also have associated with it any or all of the following flags: Non-removable, Hidden, Public Read, Read Only, Single-Valued, Sized, and String. The general me~ning~ of these flags are f~mili~r to those of skill in the art. If the Sized flag is set for a given attribute, then upper and lower bounds (possibly including No Limit) are imposed on values ~;u~ ly held by that attribute.

CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263Each object class in the schema 28 also has certain information associated with it. Each class has a name which iclentifiec this class, a set of super classes that identifies the other classes from which this class inherits attributes, and a set of collt~i,..llent classes that identifies the elasses permitted to contain in~t?n~çs of this elass. Although the topies of elass inherit~nce, S eonl~ llent, and in~t~nti~tion are f~mili~r to those of skill in the art, their use in eonneetion with applieation object classes according to the present invention is new.
Eaeh object class also has a container flag and an effective flag. The container flag indicates whether the class is a container class, that is, whether it is capable of cont~ining instances of other classes. The effective flag indicates whether instances of the class can be 0 defined. Non-effective classes are used only to define attributes that will be inhPrite(l by other classes, whereas effective classes are used to define inheritable attributes, to define instances, or to define both.
In addition, each object class groups together certain attributes. The naming attributes of a class are those attributes that can be used to name instances of the class. The m~n~1~tory 15 attributes of a class are those attributes that must exist in each valid instance of the class and/or become m~n-l~tory attributes of classes which inherit from the class. The optional attributes of a class are those attributes that may, but need not, exist in each valid instance of the class.
Optional attributes of a parent class become optional attributes of a child class which inherits from the parent class, unless the attributes are mandatory in some other parent class from which 20 the child inherits, in which case they are also m~n~l~tory in the child.
An object is an instance of an object class. Dirrtl~l.l objects of the same class have the same m~ntl~tory attributes but may have dirrclcllt current values in their corresponding m~n~l~tory attributes. Dirrclcll~ objects of the same class may have different optional attributes, and/or dirrelcllt current values in their corresponding optional attributes.

W O 97/03399 PCT~US96/11263 The directory services 24 also include an interface library 34 which provides access to the schema 28 and to a tl~t~h~e 38. The schema 28 is an API-ext~n~ihle schem~ in that the attributes and object classes found in the schema can be altered through an Application Programmers' lnterf~ce ("API") without direct access to the source code that implements the s schema 28. In some embo-liment~ the int~rf~e library 34 includes tables or comm~n~1~ stored in a file which is read by the schema 28 during its initi~li7~tion and when objects are created, thereby ~lefinin~ the available attributes and classes.
In addition or as an alternative, the intt-rf~e library 34 includes a set of routines that are available to other code to access and modify the schema 28. In one embodiment the interface lo library 34 includes an API that defines an interface to an NWDSxxx0 library 36 which is commercially available from Novell, Inc. of Orem, Utah. The NWDSxxx() library 36 is so named because the names of functions and data types defined in the library 36 typically begin with "NWDS," an acronym for "NetWare Directory Services." The use of particular elements of the NWDSxxx() library 36 in connection with the present invention is described hereafter.
The ~i~t~h~e 38 contains objects 49 and 51 that are defined according to the schema 28 and the particulars of the network 10. These objects 49 and 51 represent resources 22 of the network 10. The rl~t~hzl~e 38 is a "hierarchical" database 38 because the objects 49 and 51 in the 11~qt~b~e 38 are connected in a hierarchical tree structure. Objects in the tree that can contain other objects are called "container objects" and must be instances of a container object class.
The ~1~t~h~ce 38 is also a "synchronized-partition" database 38. The database 38 is typically divided into two or more non-overlapping partitions. To improve the response time to ~l~t~h~e 38 queries and to provide fault-tolerance, a replica of each partition is physically stored on one or more file servers 14 in the network 10. The replicas of a given partition are regularly updated by the directory services 24 through an automated synchronization process, thereby CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263 reducing the dirr~lc;nces between replicas caused by activity on the network 10. In one embodi-ment, the database 38 includes a Novell NetWare Directory Services ~i~t~b~e ("NDS ~l~t~h~ee") 40.
A~lmini.~tration and use ofthe resources 22 are ~u~olled by the dilc~;Loly services 24, by 5 ~lmini~trator tools 42, and by user tools 44. Typical ~-lmini~tr.qtor tools 42 include partition management routines 46 for m~n~ging the partitions of the database 38.
The present invention supplement.~ the previously available ~-lmini~trator tools 42 by providing application management routines 48 for creating, deleting, and modifying application objects 49 and/or desktop attributes on user, group, and container objects 51 in the ~l~t~h~e 38.
0 The addition of application objects 49 to the ~l~t~h~ce 38 and other fe~ s of the present invention make application programs 23 available to network ~-imini~trators and users in a previously unknown, umrollll7 convenient, and efficient manner.
The present invention also provides users with an application launcher 50 for initi~ting execution of applications 23 through their corresponding application objects 49. In addition, the 1 S present invention provides desktop attributes on user, group, and container objects 51 which modify previously known desktop environments 52 to facilitate the use of the application objects 49. User, group, container, and/or other objects 51 which have a desktop attribute are herein termed "desktop objects."
With reference to ~igures 1,2, and 3, the application management routines 48, as well as 20 the schema 28 and the database 38, include a tangible embodiment stored in one or more program storage devices. Suitable storage devices include floppy disks, hard disks, tape, CD-ROMs, and other computer usable media. Each program storage device is readable by one or more of the file servers 14 and user stations 16. Each program storage device tangibly embodies W O 97/03399 PCTrUS96/11263 a program, functions, or instructions that are executable by the m~c.hines 14 and/or 16 to perform application m~n~ging steps of the present invention as described herein.In one embodiment the application management routines 48 are located in a "snap-in"
module 54 stored in a .DLL file on a disk in the Microsoft(~ WindowslM environment ("Micro-5 soft" is a registered tr~lem~rk, and "Windows" is a tr~em~rk, of Microsoft Corporation).Figure 3 illustrates steps that are taken by the snap-in module 54 to modify the directory service s 24 in order to support the application management routines 48. Some of these steps modify the directory services schema 28. Modifications to the schema 28 include the addition of at least one class that defines application objects 49 and the addition of attributes which enh~n~e the 0 visibility and ease of use of those application objects 49. Other steps taken by the snap-in module 54 provide network ~rlmini~trators with control over application objects 49 by adding routines that allow ~lmini~trators to create, modify, and delete the application objects 49 available to a given user, group, or container class.
One embodiment makes the new routines 48 available through the f~mili~r NWAdmin 5 tool interface, but those of skill in the art will appreciate that the routines 48 could also be provided in connection with programs other than NWAdmin. NWAdmin is a commercially available extendable tool used by network :~-lmini~trators to manage objects in the database 38.
The module 54 extends NWAdmin to support application objects 49.
As shown in Figures 2 and 3, the initial step taken by the snap-in module 54 is a 20 registration step 60 which registers the snap-in module 54 with NWAdmin. In ~ltern~tive embodiments, the routines 48 are registered with another ~-lmini.~tration program to make them available for use by an ~tlmini~trator. During the registration step 60 menu items and ~ procedures corresponding to operations on application objects 49 and desktop objects 51 are CA 02226360 l998-0l-06 W O 97/03399 PCTrUS96/11263 registered with NWAdmin by ~ ,flate calls to the standard function NWARegisterObject-Proc().
In one embodiment of the snap-in module 54 the first application object procedure registered is SnapinApplicationProc(), a function which receives and processes messages from s NWAdmin. In response to the NWA_MSG_INITSNAPIN message, SnapinApplicationProc() initi~li7.-s NWAPageStruct intPrfare page structures titled "Identification," "Contacts,"
"Environment," "Options," "Scripts," "Lic~n5inp," and "View Associations," and registers corre-sponding menu item interf~re pages with NWAdmin. Appropriate titles for these structures and suitable groupings of the attributes and classes of the present invention under each title are 0 readily ~-termine~l by those of skill in the art. SnapinApplicationProc() also manages device context information in Windows environments and similar information in other environment~
In addition, SnapinApplicationProc() invokes NWAAddClassData() to register with NWAdmin the bitmap and other interface information associated with new application object classes added by the snap-in module 54.
s In response to the NWA_MSG_CREATEOBJECT message, SnapinApplicationProc()registers a dialog box which allows zlclmini~trators to browse through executable files on the network 10, through existing application objects 49, or both, and to optionally invoke the necessary routines 48 to create a new application object 49. Browsing may be performed with a standard browsing tool.
In response to the NWA_MSG_GETVALIDOPERATIONS message, SnapinApplicationProc() registers the following set of bitflags: NWA_OP_DETAILS,NWA_OP_RENAME, NWA_OP_DELETE, NWA_OP_DSTYPE, NWA_OP_CREATE.
Those of skill will appreciate that different operations may be valid in other embodiments of the snap-in module 54 of the present invention.

W O 97tO3399 PCTAUS96/11263 In response to the NWA_MSG_GETPAGECOUNT message, SnapinApplicationProc() first invokes a snap-in function DSGetAliasedObjectName() which returns the name of the object 49 or 51 that is referenced by an alias if an alias is passed in and returns the name passed in if that name is not an alias. SnapinApplicationProc() then creates a local copy of the 5 information in the object 49 to m~int~in a record of ~lministrator modifications to the object 49 until such time, if any, as the ~tlmini~trator directs the snap-in module 54 to enter the modifications into the ~l~t~h~se 38. Finally, SnapinApplicationProc() returns the number of interface pages to NWAdmin.
In response to successive NWA_MSG_REGISTERPAGE messages (one for each 10 interf~ e page), SnapinApplicationProc() registers the next interface page with NWAdmin.
Those of skill will appreciate that allelllalive embo-1iments of the present invention vary the order in which the pages are registered, as well as the specific manner in which information and operations regarding objects 49 and 51 are divided between the interface pages. User interface mech~nisms other than interface pages are utilized in alternative embotliments.
In response to the NWA_MSG_MODIFY message, SnapinApplicationProc() invokes a snap-in function ModifyApplicationData() to modify the specified application object 49. Here and elsewhere throughout the snap-in module 54 the ~rlmini~trator is provided with ~p.opliate error messages if a requested operation fails.
In response to the NWA_MSG_RENAME message, SnapinApplicationProc() simply 20 returns NWA_RET_DODEFAULT. In response to the NWA_MSGQUERYDELETE
message, SnapinApplicationProc() removes any relevant licensing certificate and deletes the identified application object 49. Finally, in response to the NWA_MSG_CLOSESNAPIN
~ message, SnapinApplicationProcO frees the memory it allocated, closes files (if any) that it opened, and otherwise cleans up. Some embol1iments of SnapinApplicationProc() also invoke CA 02226360 l998-0l-06 W O 97/03399 - PCT~US96/11263 NWARemoveClassData() to remove the bitmaps added earlier to NWAdmin's class tables.
Some embodiments remove the new application object classes from the schema 28, alternative embo-liment~ leave the schema modifications in place after ter ninz~tion of the snap-in module 54.
s In this embodiment of the registration step 60 of the snap-in module 54, the next application object procedure registered is SnapinDesktopProc(), which receives and processes messages from NWAdmin regarding desktop attributes on desktop objects 51 in a manner analogous to the manner in which SnapinApplicationProc() receives and processes messages regarding application objects 49. Thus, in response to NWA_MSG_INITSNAPIN, 0 NWA_MSG_GETPAGECQUNT, and NWA_MSG_REGISTERPAGE messages, Snapin-DesktopProcO creates and registers with NWAdmin an interface page titled "Desktop Objects."
Likewise, SnapinDesktopProc() takes care to identify aliases and to allow changes to desktop attributes on desktop objects 51 in the ~ t~hsl~e 38 only after confirm~tion by the ~(1mini~trator.
Other SnapinDesktopProc() steps, such as modifying or closing steps, are readily determined by those of skill in the art according to the te~ hinp~ herein.
With continued reference to Figure 3, the registration step 60 is followed by a query step 62 and possibly by a modification step 64. The query step 62 ~iet~?rmint?c whether additional modifications need to be made to the schema 28 in order to realize the present invention.
Suitable modifications include ~1efining new attributes and/or new object classes. In some embodiments the query step 62 queries the user to obtain authority to perform the identified modifications to the schema 28; in others, authority is presumed. If an additional modification is identified and authorized, it is performed during the modification step 64 in a manner which will be described in connection with Figures 5 through 7 hereafter. The query step 62 is then repeated until no further modifications are identified.

W O 97/03399 PCTrUS96/11263 After the modifications to the schema 28 are completed, the snap-in module 54 performs a context capture step 66. In one embodiment, the context is captured by the following sequence of calls:
Context = CreateContext(), s NWDSSetContext( Context, DCK_NAME_CONTEXT, DS_ROOT_NAME );
NWDSWhoAmI( Context, UserName );
The variable Context is of type NWDSContextHandle, and is a buffer used by NWDSxxx() calls. The variable UserName is an array of characters which contains the name of the user who is presently running NWAdmin. CreateContext() is a snap-in module 54 function which invokes 0 NWDSCreateContext() to create a local copy of the context, calls NWDSGetContextO to initi~ that local copy, and then sets the following bitflags in the context using NWDSSetContext(): DCV_TYPELESS_NAMES, DCV_XLATE_STRINGS, DCV_DEREF_ALIASES, DCV_DEREF_BASE_CLASS.
In modifying the database 38, care is taken to provide users of application objects 49 and 15 desktop objects 51 with ~l~t~b~e rights which include both the object's current rights and the rights specified expressly or implicitly by the network ~f1mini~trator during use ofthe snap-in module 54.
After the context capture step 66, the snap-in module 54 goes into an event handling loop which includes a message reception step 68 and a message handling step 70. The event h~n(l1ing 20 loop proceeds as set forth above in connection with the registered object procedures Snapin-ApplicationProc() and SnapinDesktopProc(), which receive the messages from NWAdmin and handle them accordingly. The event h~nclling loop also supports conventional steps such as t~rmin~tin~ the snap-in module 54.
Although an event-driven ~lmini~trator tool 54 is shown in Figure 3, those of skill in the 25 art will recognize that other progr~mmin~ paradigms are employed in alternative embodiments CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263 of the present invention. Figure 4 illustrates one alternative embodiment of the routines 48 of Figure 2 in the form of a comm~ncl-driven ~t1mini.etrator tool 72. The event-driven tool 54 and the command-driven tool 72 contain corresponding components which accomplish similar results. Additional paradigms are used in other embodiments of the present invention.
With reference to Figures 2, 3, and 4, the comm~ntl-driven tool 72 responds to an "initialize" command with an initi~ tion step 74 which initializes bitmaps, interf~(~.e pages, menus, and other user interf~ce elements in a manner analogous to the registration step 60 of the event-driven tool 54. In the embodiment shown in Figure 4, the initialization step 74 also modifies the schema 28 to add new attributes and classes substantially as described in lo connection with Figures 5 through 7. If other software in the envi~ cnt ofthe c~-mm~n~1-driven tool 72 requires page counts, page registration, identification of valid operations on the objects 49 and 51, or similar user interface information, that information is also provided by the tool 72 during the initialization step 74.
The command-driven tool 72 responds to a "configure browser" command with a browser configuration step 76 which sets default filter characteristics of a browser. Suitable browser filter characteristics include the name of an object class, a flag indicating whether to expand volumes during browsing, and a flag indicating whether to restrict selections to a single object 49 or 51. Suitable browser filter characteristics also include contextual information such as the user's name and location in the hierarchy of the network 10.
The command-driven tool 72 responds to a "create object" comm~nd with a browser enablement step 78 followed by an object creation enablement step 80. The browser enablement step 78 initiates or resumes execution of the browser, thereby allowing the ~-lmini.ctrator to scan the exi.cting objects 49 and 51, files, and/or current attribute values. Browsing allows the ~rlmini.~trator to cletermine whether an object 49 or 51 with some or all of the desired attributes CA 02226360 l998-0l-06 W O 97/03399 PCTrUS96/11263 and attribute values already exists. In one embo~iment, the browser enablement step 78 initiates execution of a flat (non-hierarchical) browser by invoking NWALaunchFSFlatBrowser().
The object creation enablement step 80 obtains the path name of a new object 49 or 5 l from the ~lmini~trator. One embodiment converts the path name to a Universal Naming Convention ("UNC") path name if n~ces~ry. The object creation enablement step 80 creates an object 49 or 51 having the given name and other attribute values specified by the ~lmini~trator or by default.
To create an application object 49, one embodiment of the step 80 first creates a local copy of the context by calling NWDSDuplicateContextO. NWDSSetContext() is then called to 10 set the DCK_NAME_CONTEXT in the local copy of the context equal to the narne of the container object in the ll~t~h~ce 38 that will contain the new application object 49. A buffer to hold the new application object 49's attribute values is allocated by calling NWDSAllocBuf() and initialized by calling NWDSInitBuf(). Mandatory attributes of the new application object 49 are initi:~li7~d by calling NWDSPutAttrName() and NWDSPutAttrVal() for each attribute.
Then NWDSAddObject() is invoked with the context and current m~n~tQry attribute values as parameters to create the object 49 in the ll~t~h:~e 40. The new application object 49's icon data is stored in a file by calling NWDSOpenStreamO, _lwrite(), and close(). Finally, the buffer and the local copy of the conte~t are freed by calling NWDSFreeBuf() and NWDSFreeContext().
Similar steps are taken with desktop objects 51.
A modification step 82 taken in response to a "modify" command perforrns in a manner analogous to the message h~ntl1ing step 70 of the event-driven tool 54 to modify the attribute values of an application object 49. In one embodiment, the modification step 82 invokes NWDSGetSyntaxID(), NWDSPutChange(), and NWDSPutAttrVal() to modify application object 49 attributes after updating a local buffer. The local buffer is allocated and initialized substantially as in the object creation step 80 and then overwritten with the modifving values.
The modification step 82 then invokes NWDSModifyObject() to make the requested changes.
A remove license step 84 is taken in response to a delete comm~n~l The remove license step 84 communicates with the licensing server and/or takes other steps readily ~iet~nnined by s those of skill in the art to remove the license rights for the application 23. A delete application object step 86 then invokes standard NWDSxxx() or equivalent routines to delete the selected application object 49.
A close-and-clean-up step 88 closes opened files, dçt~chec from the directory service 24, frees allocated memory, and takes similar steps in response to a "close" comm~n-l In one 10 embo-liment, the step 88 gives the ~-iminictrator the option of restoring the A~t~h~ee 38 and/or the schema 28 to their original condition prior to execution of the tool 72.
As shown in Figures 2, 5, and 6, the schema modification step 64 includes an attribute definition and addition step 90 which in turn includes separate definition and addition steps 91 through 120 for new attributes which are added to the schema 28 according to the present 15 invention. A description of the new attributes shown in Figure 6 is provided below.
The step 91 defines and adds a "desktop" attribute having a distinguished name attribute syntax and no flags. The desktop attribute takes as its value a list of application objects 49 that should be displayed for a given desktop object 51. In an embodiment utili~ing the NDS
database 40, the desktop attribute is added to the User, Orgzini7~fional Role, Group, 20 O~ ional Unit, and Org~ni7~tion classes. In a presently ~l~relled embodiment, the desktop attribute is not added to the Org~ni7~tional Role class because doing so degrades performance.
As used herein, the term "desktop object" includes any object 51 in the ~i~t~b~ce 38 which is an instance of a class C~ g the desktop attribute. Associating desktop attributes with container classes allows application objects 49 to be located on desktops 52 that are accessible to more than one user. In alternative embodiments the desktop attribute is added to a subset of these classes and/or to other container classes such as Country.
When an application object 49 is added to the desktop attribute, care should be taken to give the desktop object 51 read and compare rights to all of the application object 49's attributes, as well as any other rights granted to the application 23'S executable code file by the filesystem.
Otherwise, users may be unable to launch and successfully execute an application 23 even though the network ~-lmini~trator attempted to enable them to do so by placing the application object 49 in a desktop object 51.
0 To define and add the desktop attribute, one embodiment of the step 91 invokes memset() to initialize a struct in RAM to hold the new attribute's values, and then sets the syntax type in that struct to indicate that the new desktop attribute has the distinguished name syntax type. This embodiment then invokes in turn NWDSDefineAttr(), NWDSAllocBuf(), NWDSInitBuf(), NWDSPutAttrName(), NWDSModifyClassDef(), and NWDSFreeBuf() with 15 parameters readily clett~rrnined by those f~mili~r with these functions. The other attributes described herein are defined and added by analogous function calls, with parameter differences readily determined by those of skill in the art.
The step 93 defines and adds an "auto start" attribute having a typed name attribute syntax and no flags. The auto start attribute takes as its value a list of application objects 49 that 20 should automatically run on the desktop 52 when the application launcher 50 is started from the desktop 52.
When the auto start attribute is created or modified~ care should be taken to give each desktop object 51 read and compare rights to all the application object 49's attributes, as well as any other rights granted to the application 23 by the filesystem. Otherwise, an application 23 W O 97/03399 PCT~US96/11263 may fail to launch and successfully execute even though the network ~lministrator placed the application object 49 in the auto start list.
The auto start attribute is added to the desktop classes. In one embodiment these classes include the User, Org~ni7~tional Role, Group, Olg~ onal Unit, and Org~ni7~tion classes. In 5 alternative embodiments the auto start attribute is added to a subset of these classes and/or to other container classes such as Country. In a presently plc~re~ d embodiment, the auto start attribute is not added to the OrgAni7~tional Role class because doing so degrades perforrn~nc~e.
The step 96 defines and adds a "l~lmchçr configuration" attribute having a stream attribute syntax and having the Single-Valued flag. In one embodiment the launcher 0 configuration attribute takes as its value a stream. In ~It~rn~tive embo-liment.c an integer attribute syntax is used and the attribute's values are treated as bitflags and/or bitfields.
The launcher configuration attribute contains various indications regarding the desired behavior of the launcher 50. Suitable indications include an indication whether the application launcher 50 should use its default setting~ indications regarding icon refresh, an indication 5 whether a user is allowed to resize the window displaying the application object icons, an indication whether the application icons should be automatically sorted prior to their display, an indication whether the l~llncher 50's window size and position should be stored on the local disk drive, the number of container levels between the user's object and the root of the hierarchical ~l~t~b~e 38 which should be scanned for application object 49 icons to display, and an 20 indication whether to allow the user to drag and drop icons out of the l~lmcher 50 to the desktop 52.
Suitable refresh indications include an indication whether the user is allowed to m~nll~lly refresh the application object 49 icons displayed on the desktop 52 and an indication whether the application object 49 icons should be automatically refreshed after each time interval of a CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263 specified length elapses. Icon refresh is ~ cu~e~l further in connection with Figure 8. Other embodiments contain different launcher configuration indications.
When the launcher configuration attribute of a user or container object is modified, care should be taken to give the object read and compare rights to the l~llnch~r configuration 5 attribute. In one embodiment, the l~llncher configuration attribute is added to the User, Org~ni7~tional Unit, and Org~ni7~tion classes. In z~lt~rn~tive emboflimente the l~lln~h~r configuration attribute is added to dirr~ L or additional desktop classes.
The step 98 defines and adds an "icon" attribute having a stream attribute syntax and having the Single-Valued flag. In a pl~f~lled embodiment the icon attribute takes as its value a 10 stream co~ ;.lg a list of application object 49 icons in the *.ICO file format. The icon attribute is added to a generic application objects class in the schema 28.
In conventional systems, icon data defining one or more icons for an application 23 is stored in the application 23's executable file. The icons that might be displayed on the desktop 52 are therefore typically scattered among multiple file servers 14 (Figure 1). Using the present 15 invention's icon attribute to hold an additional copy of some or all of this icon data allows icons for all of the application objects 49 that are visible to the user to be obtained from the central database 38. Thus, it is not nl~ce~s~ly to attach to a server 14 that holds an available application 23 unless and until the user wishes to launch that application 23.
The step 100 defines and adds a "file path" attribute having a case ignore string attribute 20 syntax and having the Single-Valued flag. In one embodiment the file path attribute takes as its value the full path (including server name) to the application object's *.EXE, *.COM, *.BAT, or other executable file. In alternative embodiments the server name is m~int~ine~l in a separate case ignore string single-valued "server" attribute or a configurable default format. In some embodiments, the file path attribute is multi-valued rather than single-valued, and contains one W O 97/03399 PCT~US96/11263 or more executable file paths. Listing several file paths increases the possibility of l~llnehing an application 23 in the event a particular server 14 becomes unavailable. The file path attribute is added to the generic application objects class. In some embotlimente, fault tolerance is provided at a higher level by an application fault tolerance object 53 (Figure 2). The application s fault tolerance object 53 includes a list which references a plurality of application objects 49.
One suitable embodiment of the list uses an "alternate application objects" attribute having a distinguished name attribute syntax and no flags. Allr~ "~ ely, the alternate application objects attribute may be added to the generic application objects class.
Under one method of operation, the network ~timinietrator places application objects 49 10 in the same list if they differ only in which server 14 (Figure 1) holds the eYec~lt~ble code.
Thus, the application l~lmcher 50 could easily locate a repl~et-ment application object 49 to launch if a server 14 goes down. Alternatively, the "best" (i.e., newest, fastest, physically closest, located on least loaded server, or most reliable) version of an application 23 could be listed first, with less desirable versions following in order of decreasing desirability.
The step 102 defines and adds a "working directory" attribute having a case ignore string attribute syntax and having the Single-Valued flag. In one embodiment the working directory attribute takes as its value the full path (including server name) to the application's working directory. The working directory attribute is added to the generic application objects class.
The step 104 defines and adds a "flags" attribute having an integer attribute syntax and 20 having the Single-Valued flag. In one alternative embodiment the flags attribute is multi-valued.
The flags attribute value is treated as a bitset. In one embodiment the bits indicate whether to autom~tie~lly minimi7e the application window and whether to restore the original drive mappings or printer port aeeignmente after an application 23 t~rminz~.tee. The flags attribute is added to the generic application objects class.

CA 02226360 l998-0l-06 W O 97/03399 PCTrUS96/11263 The step 106 defines and adds a "blurb" attribute having a case ignore string attribute syntax and having the Single-Valued flag. The blurb value is a short description of the application 23 telling a user who may be llnf~mili~r with the application 23 what the application 23 provides and why the user might want to use the application 23. Like the icon attribute, the s blurb attribute may be used as a brief i~lentifier to access the application object 49 in the ~l~qt~b:l~e 38. The blurb attribute is added to the generic application objects class.
The steps 108 and 110 define and add a "startup script" and a "shutdown script" attribute, respectively. Each script attribute has a stream attribute syntax and the Single-Valued flag. The startup script attribute value is a script to run before the application 23 executes, while the 0 shutdown script attribute value is a script to run after the application 23 t~rmin~t~s In one embodiment, each script is in NetWare Login Script format. The script attributes are added to the generic application objects class.
The step 1 12 defines and adds a "licensing" attribute having a stream attribute syntax and having the Single-Valued flag. In one embodiment, the licensing value includes information 5 needed by the NetWare Licensing Server to verify the scope and validity of the application 23's license. The licensing attribute is added to the generic application objects class.
The step 114 defines and adds a "parameters" attribute having a case ignore string attribute syntax and having the Single-Valued flag. In one alternative embodiment the parameters attribute has a stream attribute syntax. The parameters attribute value includes 20 comm~n-l line parameters to be passed to the application 23 when it is launched. The parameters attribute is added to the generic application objects class.
The step 116 defines and adds a "drive mappings" attribute having a case ignore string attribute syntax. The drive mappings attribute value includes a list of drives which must be mapped by the application launcher 50 prior to executing the application 23. One suitable -e ~

W O 97/03399 PCTrUS96/11263 format is: Drivel := Pathl; Drive2 := Path2, and so forth. Other suitable formats follow the standard syntax for the NetWare MAP.EXE utility. The drive mappings attribute is added to the generic application objects class.
The step 1 18 defines and adds a "printer ports" attribute having a case ignore string S attribute syntax. The printer ports attribute value includes a list of printer ports which must be captured by the application l~lmeher 50 prior to executing the application 23. One suitable format is: Portl := Queuel; Port2 := Queue2, and so forth. Other suitable formats follow the standard syntax for the NetWare CAPTURE.EXE utility. The printer ports attribute is added to the generic applic~tion objects class.
The step 120 defines and adds a "contacts" attribute having a distinguished name attribute syntax. The contacts attribute value includes a list of other network users who may be able to help if this user has a problem with the application 23. In general, the public should therefore be granted read rights to the contacts attribute in each application object. The contacts attribute is added to the generic application objects class.
~ ltern~tive embodiments of the present invention select different attributes to define application objects. By way of example and without limitation, some embo-liment~ omit one or more of the attributes and attribute definition steps described above. Other embodiments omit only one or more of the following attributes: flags, blurb, startup script, shutdown script, licçn~ing, and contacts. The user interf~ce and other portions of these alternative embo~limen 20 contain corresponding changes readily ~letermined by those of skill in the art. Other embodi-ments of the invention define one or more of the attributes dir~l~lltly than the illustrative description provided above. By way of example and not limitation, in ~1tern~tive embo~liment~
one or more of the attributes sets the Non-removable flag and/or uses a different attribute syntax.

__ W O 97/03399 PCTrUS96/11263 In one alternative embodiment, the step 90 defines and adds a "handler" attribute having a distinguished name syntax and no flags. The handler attribute value includes a list of handlers such as *.INI handlers for the application 23. The handler attribute is added to the generic application objects class.
In one alternative embodiment, the step 90 defines and adds a "sealcl,l.la~ path" attribute having a distinguished name syntax and no flags. The searchmap path attribute value includes a list of di.~lolies to search for files referenced by the application 23 in a manner analogous to use ofthe f~imilislr DOS search path. The searchmap path attribute is added to the generic application objects class.
0 In one ~lt~rn~tive embodiment, the step 90 defines and adds a "catch-all" attribute having a stream syntax and no flags. The catch-all attribute value includes application-defined values, such as values in a generic data field, in order to satisfy prerequisites or to invoke options for execution of the application 23. The catch-all attribute is added to the generic application objects class.
In one alternative embodiment, a step ofthe present invention adds a "see also" attribute having a distinguished name syntax and no flags. The see also attribute value includes a list of desktop objects having a desktop attribute whose value includes the name of the application object 49. The see also attribute is added to the generic application objects class.
With reference to Figures 2 and 5, the step 90 of defining and adding new attributes is 20 followed by the step 92 of defining and adding the generic application objects class. Creation of the generic class is followed by a step 94 which defines and adds one or more platform-specific application objects classes that inherit from the generic application objects class. The steps 92 and 94 are further illustrated in Figure 7.

W O 97/03399 PCT~US96/11263 Definition and addition of a class in the schema 28 inclll(les a step 122 of allocating and initi~li7ing a buffer to hold information about the new class. In one embodiment, the step 122 includes calls to NWDSAllocBuf() and NWDSInitBuf(). During a step 124 the super classes of the new class are defined by successive calls to NWDSBeginCl~Tt~?mO and NWDSPut-S Cl~e~Ttem() or equivalent means. During a step 126 the c~ . . .ent classes of the new class aredefined by similar successive calls to NWDSBeginCl~Tt~mO and NWDSPutClassItemO or equivalent means.
During additional steps 128, 130, and 132, the naming attributes, m~nt1~tory attributes, and optional attributes, respectively, of the new class are ~l~fin~rl In one embodiment each of lo the steps 128, 130, and 132 inrl~ c an initial call to NWDSBeginClassItem() followed by calls to NWDSPutClassItem() for each of the naming attributes, each of the m~nA~tc-ry attributes, and each of the optional attributes, respectively. Finally, NWDSDefineClass() is invoked to create the new class in the schema 28.
With reference to Figures 2, 5, and 7, in one embodiment of the present invention the 15 step 92 defines and adds to the schema 28 a generic application objects class which has Top as its superclass, and Org~ni~tion and O.~ ional Unit as its co..l~;..."~nt classes. The generic application objects class is a noneffective container class having the f~mili~r common name attribute as its n~ming attribute, and having m~n-l~tory attributes which include file path, description, and common name. The description attribute's value is a name that appears 20 lln~lern~th the application 23's icon on the desktop 52. In one alternative embodiment the description attribute is optional rather than mandatory.
In another embodiment, the file path attribute is optional rather than m~n~l~tory An application object would contain a script only, with no ultimate executable l~llnch~l and turned over to the user. This would be particularly useful to perform software installation.

CA 02226360 l998-0l-06 W O 97/03399 PCTrUS96/11263 The generic class's optional attributes include the following attributes defined in the step 90 (Figure 6): icon, working directory, flags, blurb, startup script, shutdown script, licensing, parameters, drive mappings, printer ports, and contacts. Other embo-liment.s define the generic class dirr~ Lly, or omit the generic class entirely and use only platform-specific classes.
s One embodiment of the step 94 defines and adds to the schema 28 a platform-specific Windows (version 3.x and/or Windows 95) application objects class which has the generic class defined in the step 92 as its superclass. This Windows application class is an effective non-container class which inherits the naming attributes, m~n~l~tory attributes, and optional attributes of the generic class. Other embodiments of the present invention .cimil~rly define other 0 platform-specific classes for the DOS, Macintosh, OSt2, UNIX(~), and/or NT~ environments (OS/2 is a mark of Tntçrn~tional Business ~c.hine~ Corporation; UNIX is a registered tr~-lem~rk of Novell, Inc.; NT is a registered tr?~içm~rk of Microsoft Corporation).
With reference to Figures 2 and 8, the application l~nncher 50 is associated with the desktop environment 52. In some embodiments of the present invention, the application l~nnch~r 50 and the application management routines 48 are combined in a single tool, similar to NWAdmin. These embodiments allow a user to readily browse for application objects 49 and/or to perform a "Yellow Pages" search of the database 38 for a particular application object 49 and to then launch that application object 49. In other embodiments, the application launcher 50 performs a search within the ~i~t~h~ce 38 by searching the desktop attribute in one or more 20 desktop objects 51.
In "bootstrap" embodiments of the present invention, a small piece of code on the client 16 reads a user object's container object in the database 38 when a user logs on. The container object has a stream syntax "application launcher bootstrap" attribute which contains the executable code for the application l~llncher 50. One method of the present invention includes the step of reading executable l;~llncher code from the application l~llncher bootstrap attribute in the ~l~t~h~ee 38. After the bootstrap attribute value is read by the client 16, the application ]~nncher 50 is executed. Storing the application l~lmcher 50 in a streaTn attribute provides the advantages, such as replication and distribution, of storage in the ~l~t~h~ee 3 8.
With reference to Figure 8, the l~lmcher 50 performs a reading step 139. During the reading step 139, the l~lln~her 50 reads the current value ofthe l~llnrh~r configuration attribute from the schema ~l~t~h~ee 38 and stores that information in a local buffer.
In one embodiment, the value of the launcher configuration attribute, as well as the values of other attributes, are read from the schema ~1~t~h~ee 38 ~ub~ lially as follows. Two 10 buffers are allocated in the schema 28 by invoking NWDSAllocBuf(). One buffer will hold the values of all attributes of an object 49 or 51, and the other will hold those values which are of interest. The first buffer is initialized by calling NWDSInitBuf(). Calls are then made to NWDSRead(), NWDSGetAttrCount(), NWDSGetAttrName(), and NWDSPutAttrName() to copy the values of interest from the first buffer into the second buffer. Finally, one call to 15 NWDSGetAttrCount() and the corresponding nurnber of calls to NWDSGetAttrName() are made to copy the values from the schema 28 into the launcher 50's memory. NWDSCompute-AttrValSize() is called to ~lçterrnine the amount of memory needed by the l~llncher 50 to hold the attribute value(s) of interest. NWDSFreeBufO is then called twice to free the two ~l~t~b~ee 38 buffers.
The launcher 50 also performs an auto start l~nnching step 140 to launch each ofthe applications 23 specified in the auto start attribute of the desktop object 51. Embo~limente which omit the auto start definition step 93 (Figure 6) also omit the auto start launching step 140. As elsewhere, error messages are provided to the user and/or to the network ~lminietrator if an ~llell~led step fails.

CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263 As explained, the icon for an application 23 is preferably stored in the icon attribute in addition to its usual storage in the application 23's executable file. Accordingly, the application launcher 50 performs a get-icons step 142 to obtain from the directory services ~1~t~b~e 38 the icons of all applications 23 listed in the desktop attribute.
s In one embodiment, the get-icons step 142 is accomplished using software which is based generally on the icon.c file in the October 1994 Microsoft Development Library CD-ROM
distributed as part of the Microsoft Developer Network. In one embodiment, the icon.c file is modified in ways readily ~lete~rninecl by those of skill in the art to work with the Borland Object Windows Library ("OWL") rather than the standard Windows API. Thus, the MakeIconO
10 function in icon.c is modified to return a pointer to an OWL Ticon structure rather than a Windows HICON structure. The ReadIcon() function in icon.c is modified to return the icon that best fits the available screen resolution, number of colors, and system metric for the icon size rather than simply reading the first icon. Alternative embodiments use other code to read the icon data from the icon attribute and/or to create a corresponding icon for display on the desktop 52.
During a browse/search step 143, the launcher 50 performs browsing and/or searching as requested by the user. Suitable browsers for performing the step 143 include without limitation f~mili~r flat browsers, other f~rnili~r browsers, and browsers of the type provided in the NWAdmin tool. Searching during the step 143 may include specifying search parameters or 20 using previously specified search parameters. Searching may also include a specification of how much of the hierarchical ~~t~h~e 38 tree to search. Suitable search algorithms are readily ~let~ rrnined by those of skill in the art, and include without limitation algorithms for "yellow page" searches of the type performed by NWAdmin.

W O 97/03399 PCT~US96/11263After the icons are displayed on the desktop 52, the lz~l-ncher 50 responds to comm~nflc~
or events provided by the user. One such comm~n~l orders the l~llncher 50 to perform a manual icon refresh step 144. Icon refresh is useful because the network ~-lmini~trator may have added new application objects 49 to those available to the user, may have deleted other application s objects 49, and/or may have changed the current attribute values of still other application objects 49 after the l~nnl~her 50 last read those values.
The l~llnch~r 50 m~int~in~ an internal list of application objects 49 for which icons are currently displayed. The manual refresh step 144 causes the l~llncher 50 to scan a portion of the fl~t~b~ee 38 to dçt~rmine whether the launcher 50's internal list differs from the attributes listed 10 in the desktop attribute of the desktop 52 in the fl~t~b~e 38. The portion of the cl~t~b~ce 38 hierarchy searched is specified by the container levels value stored in the l~llncher configuration attribute of the user and container objects. In one embodiment timestamps are used to detect changes to the database 38. In another string comparison similar to that performed by strcmp() to detect name changes. Any dirr~ ces detected are reflected in the internal list and other 5 int~?rn~l data of the launcher 50 and in the icons displayed on the termin~l screen.
The user may also order the l~mcher 50 to perform a viewing step 146. The viewing step 146 displays the current values of predçtermined attributes. One embodiment displays all of the attributes of application objects 49 whose icons are ~;u~ ntly displayed to the user. The embodiment illustrated in Figure 8 displays the attribute values but does not allow users to 20 change those values. An alternative embodiment allows users to change the value of selected attributes, such as the parameters attribute and/or the contacts attribute.
In connection with the viewing step 146, the user is able to ask a contact for help during an asking step 148. In one embodiment, the asking step 148 includes viewing the current value o~the contacts attribute, selecting a particular contact person, and then selecting that contact W O 97/03399 PCT~US96/11263 person's email address or telephone number. In response, the launcher 50 initi~tes email corre-spondence with the contact person or dials the contact person's telephone number, respectively, by invoking standard communications software. For instance, email correspondence is readily initi~te~l by the launcher 50 through the ~e~ging API protocol promulgated by Microsoft or through other standard communications interfaces.
Of course, the user may also select a specific application 23 and order the l~llncher 50 to perform an application l~lmching step 150. In an embodiment tailored to the Windows ~llvholllllent, the application 23is selected for l~nnchin~ by double-clicking a mouse button after positioning a desktop cursor over the application 23's displayed icon. The l~llnching step lo 150 is discussed below in connection with Figures 9 through 11.
With continued reference to Figures 2 and 8, the l~nncher 50 also takes certain steps not directly requested by the user. For instance, the launcher 50 mz~int~in~ an intPrnsll structure that reflects the current status of each application 23 launched by the launcher 50. This status information includes user interface information such as drive mappings, printer port captures, 15 and server ~tt~chments made by the launcher 50 before launching the application 23, and an indication whether the application 23 has termin~tefl The launcher 50 detects tçrmin~tion of an application 23 by polling, by an interrupt or event notification, or by other f~nniliz~r means.
Changes in the application 23's status are reflected in the launcher 50's internal structure during a status updating step 152.
If an application 231~1lncht-~l by the launcher 50 tçrmin:~tes, the launcher 50 updates the status information and then cleans up during a cleaning step 154. The cleaning step 154~ which proceeds according to the settings in the application object's flags attribute, possibly includes unmapping drives, releasing captured printer ports, detaching from servers 14 (Figure 1), and releasing memory used internally by the l~llncher 50 to hold the application's status information.

W O 97/03399 PCT~US96/llZ63 If the l~lmch~r configuration attribute indicates that icons should be automatically refreshed, then an icon updating step 156 is also performed without a direct user request. Aside from being initi~t~rl by the l~-lncher 50, the icon updating step 156 is subst~nti~lly similar to the user-initiated manual icon refresh step 144. Both ofthe steps 144 and 156 are pelrolllled to s reduce the workload of the network ~1minietr~tor by reduc in~ or elimin~tin~ the need for the ~lminietrator to m~nll~lly update user desktops 52 after ch~nging the application objects 49 in the schema cl~tz~b~ee 38.
With reference to Figures 2, 8, and 9, the step 140 of l~llnching the auto start applications 23 includes repeated performance of a l~llnchin~? step 158, with one repetition being performed lo for each application 23 specified in the auto start attribute ofthe desktop 52. The step 150 of l~llnchin~ a user-selected application 23 includes a single performance of the l~lmchin~ step 158.
In the embodiment illustrated, the l~llnching step 158 includes a disabling step 160 which disables both the application status updating step 152 and the automatic icon updating ls step 156. Disabling the updating steps 152 and 156 simplifies subsequent steps ofthe l~nnching step 158 by preventing inconeiet~ncies in the l~llncher 50's status information.
During a setup step 162, a resource setup routine then sets up resources needed by the application 23 that is being launched. The setup step 162 also sets standard flags that communicate with Op~ldlillg system process creation routines. The setup step 162 is described 20 further below in connection with Figure 10.
A process initi~li7~tion step 164 invokes an operating system routine or other process initializer to initi~li7~ a process control block or similar process control structure used by the operating system. The step 164 also allocates a processor to a process, task, or thread CA 02226360 l998-0l-06 W O 97/03399 PCT~US96/11263 corresponding to the application 23. In an embodiment tailored to the Windows environment, the step 164 includes a call to ShellExecute() or CreateProcess().
An update status step 166 then updates the l~llncher 50's intern~l application status information to indicate that the application 23 has been l~lmche~l In one embodiment, the step 5 166 also records a process ID, in~f~nçe handle, task handle, or other process illentifier supplied by successful completion of the process initializer call in the step 164.
An enabling step 168 then reverses the disabling effects of the step 160. This allows the updating steps 152 and 156 to proceed again. If the user interface was changed during the step 160 to indicate that l~llnchin~ is underway, such as by displaying an hourglass cursor, then that o change is also reversed by the step 168.
During a yielding step 170, a control transferor transfers control of a processor in the network to the process initialized during the step 164. The l~llncher 50 suspends itself, invokes a sleep function, or otherwise yields control of the processor to the newly launched process of the application 23 to allow execution of the application program. In one embodiment tailored to 5 the Windows environment, the step 170 includes a call to Yield().
Those of skill in the art will recognize that other embodiments of the invention may include dirrel~lL steps which accomplish substantially the same results as the steps 160 through 170. For instance, the step 164 may be combined with the step 170 in environments which provide a single system call to create a new process and pass control to that process. In some 20 such embodiments the relative order of the steps 162 and 166 is reversed. In addition, the disabling step 160 and the enabling step 168 are omitted in embodiments which do not use interrupt or event par~ligm~ That is, the steps 160 and 168 are omitted when there is no risk of creating incon~i~t~nt status information in the launcher 50 during the step 158.

.

With reference to Figures 2, 10, and 11, a reading step 174 reads the value of the flags attribute. If the minim;7P flag is set, the l~nncher 50 launches the application 23 telling it to run minimi7~11 A drive mapping step 176 follows the sequence described in Figure 11. In the drive s mapping step 176 the "resources" referred to in Figure 11 are disk drives and the step of "cl~iming" includes mapping a drive. A port c~ g step 178 likewise follows the sequence described in Figure 11, but in the step 178 the resources are printer ports and the step of cl~imin~ includes capturing a printer port for use by the application 23. After a step 180 which determine.~ the location of the executable code for the application 23, an ~tt~clling step 182 also 0 follows the sequence described in Figure 11. In the ~ c.lling step 182, the resources are servers 14 (Figure 1) and the step of cl~iming includes ~ chin~ the desktop 52 to a server 14 that contains the application 23's executable code.
In one embodiment, the step 180 of determining the executable code location utilizes both the value of the file path attribute of the application object and the result of processing 5 references to attributes or environment variables. One suitable format is the same as that used in login or other scripts, possibly with a distinguished name prefix. In other embo-liment~ the step 180 does not reference environment variables. In environments that support UNC names, the step 180 preferably includes string manipulations to create an UNC name.
In one embodiment, a step 184 of determining the location of the application's working 20 directory utilizes both the value of the working directory attribute of the application object and the result of processing attributes or environment variables. In other embodiments environment variables are not referenced. The step 184 may also include a conversion to the ~JNC format.

W O 97/03399 PCTrUS96111263 Likewise, a step 186 Of dete~ ; l lg the comm~nc1 line parameters may utilize both the value of the parameters attribute of the application object and the result of proces~ing attributes or environment variables. ~ltçrnatively, environment variables may be ignored.
Figure 11 illustrates the structure of each of the steps 176, 178, and 182 of Figure 10. A
- 5 querying step 188 determinec whether additional resource claims made by the application 23 have not yet been addressed. Thus, in the drive mapping step 176, the querying step 188 detçrminec whether any additional drives need to be mapped by checking to see if all of the mappings listed in the drive mappings attribute have been addressed by the lanncher 50. In the port c~lu~ g step 178, the querying step 188 similarly ~lçtermines whether any additional 0 printer ports need to be captured by checking the printer ports attribute, and in the server att~rhing step 182, the querying step 188 cletermin~c whether any additional servers 14 (Figure 1) need to be <qtt~r.h~1 by checking the file path attribute.
If another resource (drive, port, or server) needs to be claimed by the application 23 that is being lz~l~nche~l and a second querying step 190 determines that the resource has not been claimed by any process, then a cl~iming step 192 claims the resource for the application 23. To make its clçtrrminations, the second querying step 190 çx~mines the intern~l status information of the launcher 50 during the drive mapping step 176 and the port capturing step 178, and calls NWGetConnectionStatus() during the ~tt~chinP step 182.
In the drive mapping step 176, the claiming step 192 provides substantially the same functionality as the famili~r DOS map commanc1 In the port capturing step 178, the cl~iming step 192 provides substantially the same functionality as the familiar DOS capture comman(l In one embodiment of the server ~ttarhinp step 182, the claiming step 192 calls NWAttachToFileServer() to create a server 14 attachment.

If the second querying step 190 determines that the resource has already been claimed by the application 23 being launched or by another process, a third querying step 194 is taken. The step 194 determines whether the previous claim and the claim sought by the application 23 are consistent. In the drive mapping step 176, the third querying step 194 passes control to an error 5 reporting step 196 if the drive ~eSi~nments already made differ from those requested in a manner that prevents any drive listed in the drive mappings attribute from being mapped. In the port c~Lulillg step 178, the third querying step 194 similarly colllpale~ previously made port zlcci~nmentS with those listed in the application's printer ports attribute. However, in the server s~tt~ching step 182, the third querying step 194 typically finds no error because desktops 52 can 0 be simultaneously attached to more than one server 14.
If the resource was previously claimed and that previous claim is con~i~tent with the needs of the application 23 now being launched, an incrementing step 198 increments a use counter that is m~int:~ined within the launcher 50. Thus, resources are only claimed as often as needed by the launcher 50 on behalf of applications 23. In particular, unnecessary multiple 15 ~tt~rhment~ to the same server 14 are avoided. During the clean up step 154 (Figure 8), the use count is decrement~d unless the flags attribute indicates otherwise. The resource is freed only when the use count reaches zero.
With reference to all Figures, articles of m~nnf~cture within the scope of the present invention include a computer-readable storage medium in combination with the specific physical 20 configuration of a substrate of the computer-readable storage medium. The substrate configuration represents data and instructions which cause the computers 14 and 16 to operate in a specific and predefined manner as described herein. Suitable storage devices include floppy disks, hard disks, tape, CD-ROMs, RAM, and other media 11 (Figure 1) readable by one or more ofthe COlllpu~15 14, 16. Each such medium tangibly embodies a program, functions, , W O 97/03399 PCT~US96/11263 and/or instructions that are executable by the mz~ehines 14 and/or 16 to perform application m~n~ging steps of the present invention substantially as described herein.
In summary, as illustrated in Figure 2 the present invention provides a computer-implemented method and al~p~dLus for con.ci.et~ntly tracking and employing information about application programs 23 and their execution environments in the network 10. Con~i~tency is achieved by gathering the execution environment information into the application objects 49 and desktop objects 51 in the database 38, and by routing ~l~t~b~e 38 ~cccsses through specially tailored tools such as the NWAdmin snap-in 54, the desktop 52 interface, and the application ncher 50. Database 38 and desktop 52 updates and refreshes are performed with the o application management routines 48 and the application l~lln~her 50, thereby reducing the effort associated with changes in the location of application program 23 executable codes or changes in the other information needed to execute the applications 23.
The invention may be embodied in other specific forms without departing from its spirit or es~enti~l characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. Any explanations provided herein of the scientific principles employed in the present invention are illustrative only. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the me~nin~ and range of equivalency of the claims are to be embraced within their scope.
What is claimed and desired to be secured by patent is:

Claims (71)

1. A method of managing an application in a network, comprising the steps of:
selecting attributes for the application, one attribute capable of having as its value a brief identifier and another attribute selected from a group of attributes comprising an icon attribute, a working directory attribute, a blurb attribute, a licensing attribute, a drive mappings attribute, and a printer ports attribute; and accessing an application object which is an instance of an application object class, the attributes for the application being associated with the application object in a database, the accessing step using the brief identifier.

2. The method of claim 1, wherein the selecting step comprises selecting another attribute capable of having as its value at least one file path specifying a location of an executable code of the application.

3. The method of claim 1, wherein the accessing step includes the step of browsing by displaying at least some of the attribute values of selected application objects in the database.

4. The method of claim 1, wherein the accessing step includes the steps of defining an application object that is an instance of the application object class and adding the created application object to the database.

5. The method of claim 1, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and deleting the selected application object from the database.

6. The method of claim 1, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and modifying the value of at least one attribute of the selected application object in the database.

7. The method of claim 1, wherein the accessing step includes the step of assigning rights to access resources in the network.

8. The method of claim 1, wherein the accessing step is followed by the step of launching the application.

9. A method of managing an application in a network, comprising the steps of:
selecting attributes for the application, one attribute capable of having as its value a brief identifier;
extending a database schema which defines a central database by defining and adding to the database schema at least one application object class having the attributes selected during the selecting step; and accessing an application object which has the selected attributes and which is an instance of the application object class in the database, the accessing step being performed after the extending step by using the brief identifier.

10. The method of claim 9, wherein the selecting step comprises selecting another attribute capable of having as its value at least one file path specifying a location of an executable code of the application.

11. The method of claim 9, wherein the accessing step includes the step of browsing by displaying at least some of the attribute values of selected application objects in the database.

12. The method of claim 9, wherein the accessing step includes the steps of defining an application object that is an instance of the application object class and adding the created application object to the database.

13. The method of claim 9, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and deleting the selected application object from the database.

14. The method of claim 9, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and modifying the value of at least one attribute of the selected application object in the database.

15. The method of claim 9, wherein the accessing step includes the step of assigning rights to access resources in the network.

16. The method of claim 9, wherein the accessing step is followed by the step of launching the application.

17. The method of claim 9, wherein the extending step includes extending a NetWare Directory Services schema.

18. A method of managing an application in a multi-server network, comprising the steps of:
selecting attributes for the application, one attribute capable of having as its value a brief identifier and another attribute capable of having as its value at least one file path specifying a location of an executable code of the application, the file path specifying both a network server name and an executable file name;
extending an API-extensible database schema which defines a hierarchical synchronized-partition database by defining and adding at least one application object class having the attributes selected during the selecting step;
accessing an application object in the hierarchical synchronized-partition database after the extending step by using the brief identifier; and launching the application by using information obtained during the accessing step.

19. The method of claim 18, wherein the launching step includes selecting an icon which is the brief identifier of the application.

20. The method of claim 18, wherein the launching step includes the step of mapping a drive.

21. The method of claim 18, wherein the launching step includes the step of capturing a printer port.

22. The method of claim 18, wherein the launching step includes the step of attaching to a server in the network.

23. The method of claim 18, wherein the launching step is preceded by the step of executing a startup script which is among the application object's attributes.

24. The method of claim 18, wherein the launching step is followed by the step of executing a shutdown script which is among the application object's attributes.

25. The method of claim 18, wherein the attributes of the application object include a command line for passing parameters to the application, and the launching step includes the step of passing command line parameters to the application.

26. The method of claim 18, further comprising the steps of:
defining an auto start attribute which has as its value a list of application objects to be automatically started by a desktop; and adding the auto start attribute to the database.

27. The method of claim 18, further comprising the steps of:
defining a flags attribute which contains a list of application settings to be utilized during the launching step; and adding the flags attribute to the database.

28. The method of claim 18, further comprising the steps of:
defining a desktop attribute which contains a list of application objects whose icons are to be automatically displayed by a desktop; and adding the desktop attribute to the database.

29. The method of claim 18, further comprising an icon refresh step for detecting changes to application objects in the database.

30. An application object in a directory services database in a computer network having at least one file server and at least one user station, the application object having a plurality of attributes, each attribute having a name, a syntax, and a current value, the syntax limiting the values assumed by the attribute, the plurality of attributes comprising:
a file path attribute having a string attribute syntax and having as its current value at least one location of an executable code of an application program;
and a common name attribute having a string attribute syntax and having as its current value a textual name briefly identifying the application program.

31. The object of claim 30, wherein the plurality of attributes further comprise an icon attribute.

32. The object of claim 30, wherein the plurality of attributes further comprise a working directory attribute.

33. The object of claim 30, wherein the plurality of attributes further comprise a flags attribute.

34. The object of claim 30, wherein the plurality of attributes further comprise a blurb attribute.

35. The object of claim 30, wherein the plurality of attributes further comprise a startup script attribute.

36. The object of claim 30, wherein the plurality of attributes further comprise a shutdown script attribute.

37. The object of claim 30, wherein the plurality of attributes further comprise a licensing attribute.

38. The object of claim 30, wherein the plurality of attributes further comprise a command line parameters attribute.

39. The object of claim 30, wherein the plurality of attributes further comprise a drive mappings attribute.

40. The object of claim 30, wherein the plurality of attributes further comprise a printer ports attribute.

41. The object of claim 30, wherein the plurality of attributes further comprise a contacts attribute.

42. The object of claim 30, wherein the plurality of attributes further comprise a handler attribute.

43. The object of claim 30, wherein the plurality of attributes further comprise a searchmap path attribute.

44. The object of claim 30, wherein the plurality of attributes further comprise a catch-all attribute.

45. The combination of a plurality of the application objects of claim 30 with an application fault tolerance object that is also in the computer network, the application fault tolerance object including a list which references the plurality of application objects.

46. A program storage device readable by a machine and tangibly embodying at least one routine executable by the machine to perform method steps for managing an application in a network containing the machine, the method steps comprising:
selecting attributes for the application, one attribute capable of having as its value a brief identifier and another attribute selected from a group of attributes comprising an icon attribute, a working directory attribute, a blurb attribute, a licensing attribute, a drive mappings attribute, and a printer ports attribute; and accessing an application object which is an instance of an application object class, the attributes for the application being associated with the application object in a database, the accessing step using the brief identifier.

47. The device of claim 46, wherein the accessing step includes the step of browsing by displaying at least some of the attribute values of selected application objects in the database.

48. The device of claim 46, wherein the accessing step includes the steps of defining an application object that is an instance of the application object class and adding the created application object to the database.

49. The device of claim 46, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and deleting the selected application object from the database.

50. The device of claim 46, wherein the accessing step includes the steps of selecting an application object that is an instance of the application object class and modifying the value of at least one attribute of the selected application object in the database.

51. The device of claim 46, wherein the accessing step includes the step of assigning rights to access resources in the network.

52. The device of claim 46, wherein the method further comprises an icon refresh step for detecting changes to application objects in the database.

53. The device of claim 46, wherein the method further comprises the steps of:
defining a desktop attribute which contains a list of application objects whose icons are to be automatically displayed by a desktop; and adding the desktop attribute to the database.

54. The device of claim 46, wherein the method further includes the step of launching the application.

55. The device of claim 54, wherein the method further includes the step of reading executable launcher code from an attribute in the database.

56. The device of claim 54, wherein the launching step includes the step of mapping a drive to a drive identifier.

57. The device of claim 54, wherein the launching step includes the step of capturing a printer port.

58. The device of claim 54, wherein the launching step includes the step of attaching to a server in the network.

59. The device of claim 54, wherein the launching step is preceded by the step of executing a startup script which is among the application object's attributes.

60. The device of claim 54, wherein the launching step is followed by the step of executing a shutdown script which is among the application object's attributes.

61. The device of claim 54, wherein the attributes of the application object include a command line for passing parameters to the application, and the launching step includes the step of passing command line parameters to the application.

62. The device of claim 54, wherein the method further comprises the steps of:
defining an auto start attribute which has as its value a list of application objects to be automatically started by a desktop; and adding the auto start attribute to the database.

63. The device of claim 54, wherein the method further comprises the steps of:
defining a flags attribute which contains a list of application settings to be utilized during the launching step; and adding the flags attribute to the database.

64. A method of using a directory service to help create an execution environment for an application program in a computer network, the method comprising the computer-implemented steps of:
selecting the application program from a collection of application programs;
locating an executable code for the application program in the network;
determining a value for at least one attribute of the execution environment by accessing the directory service and specifying at least the selected application program; and creating the execution environment for the located executable code based on at least the attribute value that was determined during the determining step.

65. The method of claim 64, wherein the creating step creates a Microsoft® Windows.TM. execution environment.

66. The method of claim 64, wherein the determining step determines a value that identifies a working directory as part of the execution environment.

67. The method of claim 64, wherein the determining step determines a value that identifies a command script as part of the execution environment.

68. The method of claim 64, wherein the determining step determines a value that identifies licensing information as part of the execution environment.

69. The method of claim 64, wherein the determining step determines a value that identifies a network resource as part of the execution environment.

70. The method of claim 64, wherein the determining step determines a value that identifies additional executable code as part of the execution environment.

71. The method of claim 64, wherein the determining step determines a value that identifies access rights as part of the execution environment.