JP2001051933A - Method for managing peripheral system using view object - Google Patents

Abstract

PROBLEM TO BE SOLVED: To adapt peripheral system management in compliance with variation in the capability of a peripheral device by enabling a user to refer to information regarding the functions of managed units of a peripheral system by a managing computer. SOLUTION: A client computer 10 is equipped with a memory 16 which stores a PSM object 18. Peripheral devices 22 and 24 have a management interface(MI) 26 and a managed entity(ME) interface 33. Each MI 26 has methods 28, 30, and 32 providing information relating to service functions of the ME 33. When a view object 36 in the PSM object 18 is executed, the method 28 judges which ME 33 supplies information regarding services to the object 36 and the method 30 passes a list of judged MEs 33 to the object 36 to display it. Then the method 32 makes the selected ME 33 execute the object by the peripheral devices 22 and 24 to display the information to the user.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to the management of a peripheral device system, and more particularly to a system for managing a peripheral device system using a view object interface for displaying the states and conditions of a peripheral device. About the method.

[0002]

2. Description of the Related Art Managing a peripheral system includes configuring the devices that make up the peripheral system, obtaining their status, and receiving events from the devices. The capabilities of the devices vary widely, and the communication protocols used to interact with the devices vary greatly. Software that manages peripheral systems
This diversity must be accommodated, resulting in systems that are often very complex. As used hereinafter, the term peripheral system includes scanners, servers, multi-function devices, and peripheral clients, such as personal computers.

[0003] Vendors constantly launch new models of peripherals, peripheral servers, and peripheral clients that further challenge the developers of peripheral system management software systems. Such software must be constantly revised to support such new devices and new device functions, further increasing the complexity of such software.

[0004] The capabilities provided by peripheral devices, peripheral servers, and peripheral clients vary based on their respective configurations. As resources are added or removed, for example, hard disks, peripheral system management must address these changes in capabilities, further increasing the complexity of the peripheral system management software.

Peripheral system management (PSM; Peripheral S)
The system management application allows an end user to perform an operation on a collection of multiple devices using a single command without repeatedly issuing the same command to each device. . For example, PSM applications allow a collection of devices to have their addresses reassigned through the use of a single instruction, but such applications do not accept the new capabilities of such devices.

[0006] The PSM application also typically displays a user interface element representing a collection of managed devices. Through this interface, a user can perform management operations on multiple devices simultaneously. In general, this interface is not extensible and does not provide the ability to substantially change the way a PSM application displays multiple devices. The PSM application, on the other hand, uses the "applet (a)
pplet) "(ie, a small program that executes in conjunction with a larger program) allows device designers to provide it. If the user wishes to manage individual devices, an applet is used to present the user with a device-specific user interface.
There is a need to allow device designers to change the manner in which a collection of devices is presented, as well as the manner in which individual devices can be viewed.

[0007] Many computers use a dynamic link library (DLL) to store a collection of subroutines. These subroutines are called when needed by a larger running program, and are called "plug-ins".
in) ". Such subroutines are often used to communicate a larger program with a particular device, such as a printer or scanner. The advantage of a DLL file is that it is not loaded into random access memory (RAM) by a larger program until it is called. The DLL file is dynamically linked to the program that uses it during execution, rather than being compiled with the main program.
link). The DLL can be shared by a plurality of programs.

[0008]

The ability to interact with more than one type of device in a peripheral system can affect a group of devices providing the same capability, and changes in the way that a group of devices is presented. There is a need for a peripheral system management system that can be adapted.

[0009]

SUMMARY OF THE INVENTION The present invention allows a user at a management computer to view information regarding the functions of a plurality of managed units of a peripheral system. Each managed unit provides one or more services for one or more client computers. Each service has an associated managed entity (ME) interface that includes a reference to one or more management interfaces (MI). Each MI includes one or more methods that provide information about the capabilities of the service associated with the ME. When a user selects a view object, a view object is executed having a function that allows the display of information about services performed by one or more of the managed units. The view object determines which ME associated with the managed unit provides information about the service. This is accomplished by invoking the execution of the management interface provider object for each managed unit, and a response to the associated ME is returned. By passing a list of MEs determined to provide such information to a management view object whose task is to retrieve such information, information for each ME can be displayed. The management view object causes the managed unit associated with each of the MEs on the list to execute a management interface object that retrieves and returns information for display to the user.

[0010]

DETAILED DESCRIPTION OF THE INVENTION Network software
It must interact with the physical devices connected to the network. In the past, this has been achieved by describing the physical topology and assigning a name to each machine. However, software located in many locations cannot be described in this way because the physical topology varies from site to site. The present invention provides a logical topolo that describes the roles (or services) that a machine plays / provides, rather than specifying a particular machine.
gy).

[0011] Examples of roles played by machines in peripheral system management (PSM) software embodying the present invention are given below.

The management client machine (Management C)
lient Machine): User for PSM software
The role of the machine that presents the interface. For example, the role of a management client is performed by any machine running a web browser used to access a network management program.

[0013] Management Server machine
Machine): logic for PSM software
Provide the role of the machine. For example, a server machine on which a network management program is installed performs the role of a management server machine.

A peripheral client machine (Peripheral C)
lient Machine): The role of the machine that uses the services provided by the peripheral device. An end user's workstation using a printer is an example of a peripheral client machine.

Peripheral server machine (Peripheral Server)
Machine): The role of a machine that mediates access to services provided by peripheral devices. A Windows NT (Microsoft trademark) machine sharing a printer is an example of a peripheral server machine.

Peripheral Machine: The role of a machine serving as a peripheral device. Printers and scanners are examples of peripheral devices.

Peripheral Directory Machine: The role of the machine providing the services used to locate the Peripheral and Peripheral Server machines.

A physical machine performs multiple roles,
Note that multiple services can be provided. For example, a central server acts as both a management server machine (the machine on which the network management program is installed) and a peripheral server machine (eg, a printer server).

Peripheral management software incorporating the present invention can detect, organize, display, modify, and monitor MEs for peripheral devices. The ME is a software object through which the role of the device and the services provided by the device can be managed. Again, one device can have multiple roles and thus can be associated with multiple MEs.

An ME is an architectural abstraction used to model what is being managed.
ectural abstraction). The ME is detected by the architectural abstraction of the explorer. M
E is represented by the architectural abstraction of the view. The ME is modified by the architectural abstraction of the operation.

As will be better understood from the following description, each of the abstractions specified above has its state (state) in a "variable" in the classical sense, with one or more It is configured as a software object that implements its actions in a method. The various objects described below are:
Provide PSM software that incorporates the present invention in a substantially flexible manner, adapting to system and software changes.

There is often a need for a user to evaluate the state of one or more peripheral devices, or the conditions that control the role played by the peripheral device. In addition, the addition of new types of devices that play a different role adds monitoring code (monitoring cod
e) frequently requests rewriting. Plug-ins are known in the prior art as described above, and are, for example, dynamic link libraries (ie, DLLs for systems that use the Windows operating system, where "windows"
s) "is a trademark of Microsoft Corporation). When a plug-in containing such a DLL is loaded, the included program is made executable by the operating system. However, the prior art is entirely composed of special applications,
I didn't have a plug-in that worked across many types of peripherals, except for matching interfaces.

As will become apparent below, the present invention incorporates a view object, preferably operating in the form of a plug-in, but interacts with any ME that includes the management interface required by the view object. Adapt to work. The invention can also be configured so that the view objects are incorporated into the application, rather than being configured as plug-ins.

As long as the peripheral includes or is associated with a management interface that provides the desired information, the view object
Allows a user to view various characteristics of one or more peripheral devices via a display. If you believe that the peripheral device has the required management interface support,
The execution of the view object activates the peripheral's management interface and executes and activates one or more methods incorporated therein. The result of such an execution is that information about the peripheral is returned to the view object contained in the application from which the user viewed it.

Before describing examples of the operation of view objects, various software structures representing the invention will be described.

Managed Entities The definition of managed entities is described below. ME stands for peripheral management problem doma
in) represents an element that can be recognized by the user. The ME provides a collection of one or more Management Interfaces (MIs). MI interacts with ME (or M
E) (identifier E).

The user responsible for managing the printer is:
Aware of the existence of printers, printer servers and printer clients. This user interacts with each of these elements to solve the problem with or without PSM software. This same user probably does not know the detailed architecture of the spooler. The presence of a port monitor or print processor is completely independent of such a user. In solving the problem, the user is only interested in familiar elements. These familiar and easily recognized elements are the basic units of management that users expect to find in PSM software. The object that represents the basic unit of these managements is M
Called E.

Each of these basic units of management is divided into additional elements. For example, a print server comprises a spooler, and the spooler comprises elements such as drivers, port monitors, and print processors. While each of these elements may need to be managed, they are generally managed in the context of managing a print server. The user interacts with the print server to update the driver on a particular print server.

The collection of MIs provided by the ME is:
Extensible. For example, if this interface is PSM
The printer can provide an interface to manage (ie, add or remove) the functionality of the printer, even though it was not previously envisioned in software. To use the interface, operations and view objects (described below) are provided.

The collection of MIs provided by the ME is:
It is also dynamic. At runtime, the collection of MIs can be changed. If the resources available to an ME change, the MI provided by that ME can change. For example, a printer may or may not have a hard disk. If you don't use a hard disk, because the presence of a hard disk determines whether it has the potential to manage mass storage fonts,
No MI is provided for managing mass storage fonts.

The MI supported by a particular ME
(And the functions they contain) can be queried at runtime. Applications that query MIs do not necessarily need to know how to use them. Instead, the application simply asks each ME what M
I provide a component that understands these interfaces by tracking what provides
I can be matched. For example, an application that knows nothing about the MI used to manage fonts will match operations that require a font management interface to the ME that supplies that interface.

Management Interface (Management Inter
faces ) An object usually has one static interface. However, having only one interface means that every time the capabilities of the object are changed, the interface must be changed. Having multiple revisions on the same interface is confusing. In the present invention, this is the management interface (M
This is avoided by ensuring that one or more objects, each called I), represent an ME with multiple interfaces. The MI includes one or more methods to interact with the specific capabilities of the ME. Thus, other individual objects can reuse these MIs. Furthermore, these MIs can be traversed at runtime without recompiling.

The granularity of an MI is a design decision that does not affect its usefulness. The MI can include a large set of unrelated functions or a small set of closely related functions. For example, MI called "NewLaserJet"
Is the new "LaserJet" printer ("LaserJet"
Is a trademark of the "Hewlett Packard Company"). The same set of functions is, for example, "ChangeO
nlineState "," PrintTestPage ", etc., may be placed in some MI related to a specific function. It is also possible to support both finer and coarser granularity interfaces by using multiple inheritance to construct a coarser interface from several finer interfaces. The use of a coarse-grained interface requires less code, while a fine-grained interface is generally easier to understand and easier to provide greater extensibility.

FIG. 1 shows a typical ME object in terms of an MI that allows the retrieval of the functional information of the device providing the role represented by the ME. Each MI includes one or more functions, some of which may enable the acquisition of information from the device,
Some allow the associated device to perform the function. It should be recalled again that the ME corresponds to the role performed by the device and that the device does not need to correspond to the device as a whole unless only one role performs.

The inheritance diagram of FIG. 2 is a unified modeling language diagram showing how MI relates to ME.
deling language diagram). Arrows connecting the ME to the MI box and the “ManagementlnterfaceProvider” box indicate inheritance. More specifically, inheritance determines when a program is compiled
Requires that the ME object perform all methods of the interface that is inherited. The ME object is the provider of the MI and is itself the MI.

The management interface provider object shown in FIG. 2 contains three functions used by the PSM software. "Has Management Interfa
The "ce ()" function determines whether the ME can return a pointer to the specified MI. "Get Management
The "Interface ()" function returns the MI that is used to retrieve information about the associated ME or to cause the ME to perform any function. "Get Management Interfa
The "ce List ()" function returns a list of related MIs.

FIG. 3 shows a common relationship in which various types of MEs, peripheral devices, peripheral device servers, and peripheral clients derived from “PrintPathManagedEntity (print path managed entity)” become part of the print path. Is shown. FIG. 3 is not intended to be complete. It is possible to have other types of MEs. For example, a printer may have a third-party additional output bin that folds paper and fills them in envelopes. Such a device may be a different ME than the ME that represents the printer.

The MI can be derived from other MIs. If the derived MI is supported by the ME, the ME should support the parent MI of the derived MI. Providing a parent interface is not usually a problem, as most component technologies support interface inheritance.

FIGS. 4 and 5 provide examples of how a typical managed entity class is derived. FIGS. 4 and 5 include two non-ME management interfaces (“ChangeOnlineState” and “PrintTestPage”). “LaserJet2000” and “LaserJet2001” do not necessarily need to be defined as unique MEs. They can be provided simply as the ME of the printer and provide any other supported MI.

ME Location The ME object can be located in one of three locations. That is, the ME is embedded inside the machine it represents (as described in the example below) or
It is located on the machine that is directly connected to the machine it represents, or is located on the management server machine.

The main advantage of an embedded ME object is that it eliminates reliance on existing protocols. When the ME object is embedded in a device, it can interact with the device in a device-specific manner. Since retrofitting an embedded ME to all existing peripherals is impractical, the ME object may be located on a management server and may communicate using existing protocols. This is the main advantage of placing objects in the management server machine. M for directly connected machines
The main advantage of placing E is to overcome the situation where peripheral devices are not connected to the network. Because distributed component technology requires network connectivity, the ME of a directly connected machine must proxy for directly connected devices that cannot access the network.

The location of the ME may change over time. Consider a peripheral device with embedded ME that was not configured with an IP address. Without the IP address (or other network protocol support), communication with the embedded ME is not possible. To accommodate this situation, a proxy ME is created on the management server machine. This surrogate ME does not support all interfaces provided by the embedded ME,
Supports an interface that can set an IP address. After the IP address is set,
The embedded ME replaces the ME proxy on the management server machine. The database and explorer abstractions (described below) are responsible for ME creation and replacement.

[0043] The definition of explorer (Explorers) explorer described below. An explorer is an object that detects devices corresponding to MEs, creates MEs (if necessary) corresponding to these devices, and sends ME references to a database used to track them. The explorer has states and can be configured.

Operations and views (described below) do not interact directly with the device. Instead, they interact with another object (eg, ME). This frees the object from knowing the details of how to communicate with a particular device, as various implementations of the ME abstraction encapsulate this knowledge. The MEs are either embedded in the device they represent, or located on any other machine (eg, a surrogate). Embedded ME is
When the devices on which they reside (and represent) are launched, instantiate (instantiate;
instantiate). Non-embedded MEs are not present until the device they represent is detected. When this occurs, the appropriate type of ME is instantiated. (The appropriate type is determined by querying the device during discovery.) Different explorers provide for detecting different MEs. That is, there is an ME for the role of a printer, an ME for the role of a scanner, and the like. The explorer simply discovers the device, creates the ME as needed, and passes the ME to the database abstraction (described below). There are hundreds of types of devices that support ME, and are increasing over the years. To address this, the explorer must assign a device type to the ME creation procedure.
Is used to determine how to generate an ME for a particular device type. Since ME encapsulates the mechanism for communication,
Various types of MEs can be created depending on how particular types of devices connect. For example, a directly connected laser printer may be represented by a different type of ME than a laser printer connected through a network. Since a different type of explorer than that for detecting network devices is used to detect directly connected devices, the explorer uses a different M to build the ME.
Use the E creation procedure.

Although a specific method for instantiating a ME has been described above, it is important to note that the above method is merely an example of how a ME can be constructed. is there. Each explorer is free to implement its own mechanism for instantiating the ME. In fact, when detecting existing MEs (e.g. embedded in the device), the explorer does not instantiate any MEs (since they have already been instantiated when the device comes up).

Example of Explorer: A local IP subnet explorer will be described. Often the most important devices are local
This is a device on the subnet. These devices can be detected by a network management program, but instead of creating a record for a database program, an appropriate type of ME is created.

The direct connection explorer (DirectConnect)
Explorer). Explorer examines all local ports for directly connected devices,
Based on its detection, it can be made to create an appropriate type of ME to represent a directly connected device.

[0048] Server Explorer
r) will be described. The explorer can be made to "discover" the ME from the server. Such explorers are used in environments where there are already servers that regularly perform the discovery. This can be used to reduce network traffic and increase performance.

The managed entity explorer (Ma
naged Entity Explorers). It may not be appropriate to detect all MEs on the network. Many MEs are intended to be proxies placed on a management server and used only for the management application of that management server. However,
Other MEs may be embedded inside the peripheral device with the intent that these MEs are used by remote peripheral management software. The PSM software does not detect MEs that are not suitable for detection by using existing naming services, but can detect those MEs that are suitable for detection. For example, such an existing naming service is a CO
BRA naming service (common object request
broker architecture). Since the MEs themselves know if they should be accessed from the outside, they can register with the naming service and allow them to be located remotely. This solution may require that one naming service be established on the network. Another solution is to use another protocol (eg, SNM
P or "Simple Network Management Protocol")
Is to detect the device, and to use the attributes of the protocol to identify the device with the embedded ME. Providing a naming service is avoided, though each of the underlying protocols requires a different explorer to help detect the embedded ME.

[0050] For the definition of the operation (Operations) operation will be described below. An operation is an object that operates on a collection of MEs using the MI. Each ME in the collection to be executed must support the MI required for the operation. Operations have states and can be configured.

In the same way that a new MI is specified,
New operations can be defined to use the MI. A PSM application can simply support general operations without specific knowledge of the specific operations. An operation requests a certain MI from the ME on which it operates. An operation can require one or more MIs, but requires at least one.

Depending on the operation, M in the collection
The order of E may or may not be important. For example, the order is important for the operations used to assign IP addresses to a collection of MEs. However, the order is not important to the operations used to update the firmware.

An operation may or may not be configurable depending on the operation. Operations that simply change the state online are:
No configuration is required. For configurable operations, an applet is provided that knows how to configure that type of operation. The applet is responsible for providing a user interface that allows the state to be changed. Such an applet runs on an administrative client and configures operations by invoking methods.
In a preferred embodiment, the applet is Java
Written in

An example of the operation will be described below. The online operation will be described. "Chan" shown in the class hierarchy diagram of FIG. 4 and FIG.
geOnlineState (change of online state) ”. This MI is the M that supports this MI.
Allow E's online state to be changed. Operation is “ChangeOnlineState” MI
To ensure that the online state is online. Online operation can be used to create management applications that periodically bring all printers online.

The Install Font Operation (InstallFont Operation) will be described. Consider the following interface used to manage true type fonts.

[0056]

[Table 1] interface TrueTypeFontManagement: Managementlnterface {void Add (Font f); void FontList List (); void Remove (FontListElement f);

Now consider a peripheral system management application that installs fonts on end-user machines (eg, PCs) and printers. Such an application can be built using the operation of installing a font on a machine that supports "TrueTypeFontManagement". The application displays "True
Simply identify all MEs that support the "TypeFontManagement" interface and use "In" in the desired font file.
Configure the "stallFont" operation to invoke the operation on the identified ME earlier.

Sequential network address specification operation (AssignSequentialNetworkAddress)
es Operation) will be described. A subnet (su
If the physical network changes from bnet) to another subnet, it is necessary to renumber all devices on the physical network. Network managers support a mechanism for sequentially reassigning network addresses to all devices (managed by these applications) on a physical network. This can be achieved using operations. Such operations are configured using a range of network addresses. The peripheral to be renumbered is then selected by the application (with or without application-dependent user intervention). Eventually, "AssignSequentialNetworkAddresse
An "s" operation is invoked on the previously selected collection of peripheral MEs.

[0059] the definition of the database (Databases) database described below. The database is
An object that receives the ME, handles the duplication, and stores the ME for later availability. The database may also be purged of a particular ME or all MEs.

Database abstractions allow other architectural abstractions (eg, explorers, etc.) to interact with many types of databases without knowing the specific type of database. The application is aware of the specific type of database at the time of use, and is free to use all its features, no matter what underlying database management system is used. The purpose of the database abstraction is to provide objects that allow the explorer to interact with and communicate with the application's storage mechanism.

An example of the database will be described below. A file-based database will be described. ME for any application
It may be acceptable to simply have a file containing a list of. A file-based database can be created by implementing the interfaces specified for database abstraction (add, removeOne, removeAll), which records information about the ME in a file. If ME is added to the database, the information needed by the application,
One line is added to the file with the information needed to uniquely identify the ME (and to support the removeOne and duplicate operations).

An object-oriented database (Object-O
Riented Database) will be described. For any application, the flexibility provided by the object-oriented database can be attractive. Such a database can be implemented (on an object-oriented database) in the same way as implemented for a file-based database.

The relational database (Relation
al Database). For applications that require database performance, using a relational database can be attractive. Such a database can be implemented (on a relational database) in the same way as implemented for a file-based database.

Views The definition of a view is described below. A view is an object that displays a collection of MEs using the MI. Each ME in the displayed collection must support the MI required by the view. Views have states and can be configured.

A view is similar to an operation except that the ME is displayed instead of running on the supplied ME. Views are state, configuration (config
uration), can be divided into three parts of the display.
States track the current configuration and have no user interface. The configuration is similar to the configuration applet for operations. It is responsible for presenting a user interface that allows the state to be changed. The display is responsible for displaying a collection of MEs. The order of MEs may or may not be important depending on the view. Some views simply ignore the order of MEs in the collection and simply display the top three MEs of interest (and the remaining summaries). There may also be views that display all MEs in the order provided in the collection. One or more instances of the view (inst
ance) can exist simultaneously in different states.

An example of a view will be described below. The consumables view will be described. It takes time when the printer runs out of toner. Replacing a toner cartridge takes longer than replacing a cartridge by a professional because the user is often untrained. An unskilled user can destroy a printer by bouncing. To address this problem, it is advantageous to have a means to find out that the printer is almost out of toner. This allows the toner to be replaced before it is exhausted. This is accomplished using views. Such a view displays printers below a certain toner threshold and indicates a minimum to maximum amount of toner. By changing the low toner threshold, the user can change the number of printers displayed. If the low toner threshold is set to 100%, all printers will be displayed.

The scanner view will be described. This view displays a particular type of ME. Views may be created for a printer and indicate the maximum number of pages per minute that the printer can send. The view for the scanner has a field (fi
eld). Thus, the view is generated to support a particular type of ME and displays fields that indicate that type.

The map view will be described. When composed of maps, views can be constructed to display MEs according to their location on the map. The location of the ME is stored in a location file (location file; locati) containing the state of the map view.
on file). Since a view has a state, that state can be used to store information resulting from the interaction between the user and the view.

System Configuration Referring to FIG. 6, there is shown a system for implementing the present invention. The client computer 10 includes a central processing unit (CPU) 12, a network interconnection module 1,
4 and memory 1 for storing the PSM object 18
6 is provided. PSM object 18 contains the necessary code to utilize the various objects described above, and manages a plurality of peripheral devices that can be accessed through network 20.

Each of the peripheral devices 22 and 24
"Has Interface Method" 28, "list interface Met
hod "30 and" get interface Method "32 in that order. Each peripheral device further includes one or more embedded ME objects, each enabling a reference to one or more MIs that allows for obtaining information about the role of each peripheral device. As noted, each MI is an object that includes at least one function that allows obtaining information about the role performed by the respective peripheral.

In the following, it is assumed that all objects have already been loaded into memory and are ready for use. However, providing such an object to one or more data storage devices, such as, for example, a magnetic disk 29,
It is also within the scope of the present invention that the contents can be loaded into memory as needed.

Further, memory 16 includes one or more explorer objects 34, each of which includes a method for obtaining a reference to the ME object. The ME objects referred to here are one or more selected MEs, their states (described above), and view objects 36 that allow the display of configurations, MI (described above). An operation object 38 operating on a collection of MEs using
A database object 40 (described above).

Example of view application: “Consumables
To better understand the operation procedures 18 of the PSM during execution of the "Consumable Management View" view object, reference is made to FIGS. A logic flow diagram of the method of the invention is shown,
An application responsible for using a "management view" to monitor consumable levels is shown. This “management view” is called a “consumables management view”. In this example, a network management application (hereinafter referred to as an Administrator) allows a user to monitor the status of a selected printer consumable using a "consumables management view."

The “consumable supplies management view” (CMV) is a plug-in type view object that is responsible for displaying the consumable supplies status of a group of printers. In this context, consumables refer to toner. In other cases, the term "consumable" can be paper, ink, or even a printer part with a set life. CMV indicates a printer that has a low toner level. What is meant by “low” is a parameter that can be set by the user. Some users are interested in whether the toner level is less than half of full capacity, while others are interested in whether the toner level is less than 1/4 of full capacity. For this reason, CMV
It can be configured to set a "low" toner level.

A color laser printer typically has four different types of toner (cyan, magenta, yellow, black). Monochrome printers have only black toner. In this example, if any one of the toner levels is considered low, the printer considers low toner. Briefly, no special instructions are given as to what type of toner is low. CMV simply indicates that the printer has low toner.

The user may choose to use the capabilities of the CMV through a special application specially written for consumable management, or the user may use that capability through a common application (eg, an administrator). Can be used.

The “administrative view” includes a user interface, for which implementation of a particular administrative view can be performed, for example, by using “Microsoft Windows (Microsoft Corp.)”.
oration trademark) "
Must be tied to the program. The management view is contained inside a dynamic link library (DLL). Although a Windows DLL is used in this example, the administrative view is
It may alternatively be implemented in interface technology (eg, Java instead of Windows).

The steps in the example proceed as follows. 1) The administrator starts (step 50).
Through any of a variety of prior art mechanisms, the administrator discovers the printers on the network and a "Managed Entity (ME)" representing each printer.
Get. For simplicity, assume that all printers on the network include an embedded managed entity. The reference to the embedded managed entity is stored in a regular data structure such as a linked list or an array.

2) The administrator looks in the directory containing the view. This directory is called "C: \ A
dministrator \ views ". Administrators see this directory for DLLs. The administrator loads each DLL (step 52) and returns a display string, a DLL called "GetMenuName".
Call an entry point (DLLentry point) and then unload the DLL. The administrator creates a data structure that maps DLL names to display string names. This data structure can be a linked list or a table. The administrator uses this data structure to generate a Graphical User Interface (GUI) menu. Each display string is added as a menu item to the menu title "views". One of the management views in this list is a “consumables management view”.

3) The user selects the "consumables management view" (step 54). In response, the administrator loads the DLL corresponding to the “consumables management view” and “CreateManagementView”.
Calls a function exported from the DLL of the management view called. This function creates an administrative view object (ie, a data structure that contains data and pointers to methods). The data members of an administrative view object are determined by a particular type of administrative view. In this case, the "consumables management view" includes data members that track two things (low consumables threshold and refresh interval).

The low consumables threshold parameter is a percentage of consumables that determines whether the consumables level is low. If the remaining percentage of the consumable is less than this percentage, the consumable level is considered low. The refresh interval parameter relates to the period at which data updates (or "refreshes") occur. Preferably, the "management view" is updated periodically.

The pointer to the method is an object
Determined by type. In this case, the object
The type is “management view”. The "Admin View"
Has many methods.

[0083]

[Table 2] void Configure (HANDLE hParentWlndow)

This method accepts a handle in the parent window and allows the user to configure the internal state of the "admin view" (dial
og). For the "consumables management view", a dialog box is displayed showing the low consumables threshold parameter and the replenishment interval parameter. The user can change these values as desired and then "OK" to apply the changes, or "Cancel" to reject the changes and return to the state of the values before the dialog box was displayed. Can be selected.

[0085]

[Table 3] void Display (HANDLE hParentWindow, Managed
Entity * mes, unsigned intime_count)

This method displays the supplied managed entity in a window.

[0087]

[Table 4]-char ** RequiredManagementlnterfaces ()

This function returns an array of strings indicating what management interface this management view requires. The last string in the array is NULL.

4) After loading the DLL and creating the "Consumable Management View" object, the administrator calls the "Configure" method to allow the user to change the default settings. (The object has, for example, a low consumable threshold of 30 and a
Generated according to default settings such as the refresh interval in seconds. )

5) Once the user has modified the composition of the "Consumables Management View" object, the next step, if desired, is to display the view. To do this, the administrator must use the "RequiredMana
gementlnteraces (request management interface) "(step 56). In the case of the “Consumables Management View”, the only management interface required is “Ma
nageConsumables ”.

6) Next, the administrator sets “HasManagementlnterface” for each of the managed entities.
And the managed entity displays "ManageConsumable
Test for "s" support. Managed entities that support this management interface
Stored for later reference.

7) Next, the administrator sets “Disp.
lay "on the" Consumables Management View "object and pass it an array of managed entities.

8) When the “Display” method of the “Consumables Management View” object is activated, “ManageConsu
mables ”management interface, (“ Displa
The pointer to the "ManageConsumables" management interface of each managed entity, confirmed by the "y" method), is stored in a data structure such as a linked list or array. The "ManageConsumables" management interface takes the string "ManageConsumables"
s "on each managed entity that has" GetMana
gementlnterface "(step 62). The "ManageConsumables" management interface has certain methods. It is "Ge
tConsumableLevelPercentage () ". This function returns the remaining percentage of consumables.

9) The "Display" method of the "Consumables Management View" object then calls "GetConsumableLevelPercentage" for each of the managed entities.
(Consumable level percentage) "method is called to extract the remaining percentage of the consumable (toner or ink) (step 64). This value is stored in association with the managed entity and this value. After all consumable remaining percentages have been retrieved, the refresh timer is set (step 66). This refresh timer is used to ensure that the parameters are refreshed periodically. The value of the timer is set to the refresh interval.
(The timer is a prior art operating system data structure that accepts functions, (or semaphores (se
any parallel processing control data structure like maphore)
It is. When the timer expires, the method is invoked, the semaphore is signaled, or any similar action occurs to notify the program (in this case, the CMV) to execute any timer associated with the processing. . )

10) Each percentage is then compared to a low consumable threshold (also a percentage) (step 68). If the value is below the low percentage threshold, it is considered low. This means that it will be displayed. All managed entities that have low consumables are stored in individual temporary data structures (eg, linked lists or arrays).

11) The managed entity in the temporary data store is then displayed on the screen (step 7).
0). Windows are created to display them on the screen (so the handle to the parent window is passed to the display; this handle is required by Microsoft Windows to create the window). Each of the managed entities in the list is displayed with a consumable remaining percentage. This allows the user to be immediately aware of printers that need to replace consumables. At this point, the view relinquishes control to the operating system, and its window responds to events from the operating system (including timer events, discussed below).

12) After any time, which is tracked using the refresh timer set in the previous step, the timer expires. At this point, the method is called to indicate that the timer has expired. Steps 60 to 72 are repeated accordingly. this is,
Continue indefinitely until the administrative view is broken (due to user input).

From the above description, it will be appreciated that the management views allow management capabilities to be added to the management applications after they have been deployed. This is important because it allows the manufacturer to extend the management application (this may be created by a completely different mechanism). Management views can be shared between any applications. This means that the ability to manage is a problem specific "vertical" Manage application.
ment application) and general purpose "horizontal" Managemen
t application).

Examples of other management view capabilities are described below. 1) The use of a management view to select some managed entities is described. Some management views can include the ability to allow selection of managed entities. Additional functions provided by the management view object allow the host program to obtain a list of selected managed entities (in such cases). The return value indicates the number of selected managed entities and a pointer to the actual managed entity.

2) Describe the use of a management view to select one managed entity for "default" operation. (This is typically done in the window by double-clicking the item.) This requires preparation for a callback. One possibility is to provide a method when creating the management view. This function is called each time one managed entity is selected for "default" operation. This is typically achieved by double-clicking on a visual representation of the managed entity.

It is to be understood that the above description is only illustrative of the invention. Various alternatives and modifications can be made by those skilled in the art without departing from the invention. Accordingly, the invention is intended to cover all such alternatives, modifications, and variations that fall within the scope of the appended claims.
And to incorporate transformations.

The present invention includes the following embodiments as examples. (1) A method for allowing a user to view information on the functions of a plurality of managed units 22 and 24 of a peripheral system on the management computer 10, wherein each managed unit 22 and 24 Or provide one or more services for multiple client computers, each of which includes an associated managed entity (ME) interface 33 that includes a reference to one or more management interfaces (MI). And each MI 26 includes one or more methods 28, 30 that provide information about the function of the service associated with the ME, wherein the methods 28, 32 are associated with one or more of the managed View-O with a function that can display information about the services performed by the units 22,24. The object 36, in response to the user selecting comprises the step of executing the view object 36, the view object 36,
(I) By invoking the execution of the management interface provider object 26 of each managed unit 22, 24 to return an answer to the associated ME 33, which ME 33 associated with the managed unit 22, 24
Determining whether to provide information about the service; and (ii) passing the list of MEs 33 determined to provide the information in step (i) to a further object whose task is to retrieve the information. Displaying said information for each ME, and (iii) causing said further object to be executed to execute a management interface object 26 in a managed unit 22, 24 associated with each of said MEs 33 on said list. Fetching and returning the information for display to the user by the management interface object 26; and displaying the information for display to the user;
A method that includes

(2) The view object 36 is
The method according to (1), wherein the application is loaded as a plug-in into the currently operating application and can be executed.

(3) When the management interface object 26 has an associated MI corresponding to the queried function,
The method according to (1), including a method of determining whether or not the ME has an object, a method of retrieving the associated MI object, and a method of listing the MI objects associated with the ME.

(4) The method according to (1), wherein the managed units 22 and 24 including the specific service indicate the service with substantially the same ME interface.

(5) The method according to claim 4, wherein the managed units 22 and 24 including a specific function indicate the function with substantially the same MI object.

(6) A storage medium 29 for controlling the processing device 12, wherein a user
A method for enabling information about the function of a plurality of managed units 22, 24 of a peripheral system to be viewed, wherein each of the managed units 22, 24 is one for one or more client computers. Provide one or more services, each of which has an associated managed entity (ME) interface 33 that includes a reference to one or more management interfaces (MIs) 26, each MI 26 comprising: A storage medium 29 comprising one or more methods 28, 30, 32 for providing information regarding the function of the service associated with the ME, wherein the storage medium 29 comprises: Information on services performed by one or more of the managed units 22, 24 Means for executing the view object 36 in response to a user selecting a view object 36 having a function that can be displayed, the view object comprising: (i) each managed unit 22 , 24 by invoking the execution of the management interface provider 26 and returning an answer for the associated ME 33, the information about the service is stored in any ME associated with the managed unit 22, 24.
Processor 1 so as to determine whether
And (ii) the ME 3 determined to provide said information in said step (i).
Means 29 for controlling said processor 12 to display said information about each ME 33 by passing the list of 3 to a further object whose task is to retrieve said information; And execute the M on the list.
At the managed units 22, 24 associated with each of the E33s, the management interface object is executed so that the management interface object retrieves and returns the information for display to the user. Means 2 for controlling
9. A storage medium 29 including:

(7) The storage medium 29 according to (6), wherein the means a) controls the application to load the view object as a plug-in from a dynamic link library.

(8) means for controlling the processor to determine whether the ME has an associated MI object corresponding to the queried function, and the processor to retrieve the associated MI object. The storage medium 29 of (6), wherein the management interface object 26 includes means for controlling and means for controlling the processor to list the MI objects associated with the ME.

(9) The storage medium 29 according to (6), wherein each of the managed units 22 and 24 including a specific service indicates the service with substantially the same ME interface.

(10) The storage medium 2 according to (9), wherein each of the management units (22, 24) including a specific function indicates the function with substantially the same MI object.
9.

[Brief description of the drawings]

FIG. 1 is a schematic diagram of a typical ME data structure.

FIG. 2 is a unified modeling language diagram of the relationship between ME and MI classes, showing that ME is a subclass of MI.

FIG. 3 shows various types of MEs.

FIG. 4 (upper part) and FIG. 5 (lower part) show an example of derivation of ME class,
One MI is shown. The ME also indicates how multiple inheritance is used.

FIG. 4 (upper part) and FIG. 5 (lower part) show an example of derivation of an ME class.

FIG. 6 is a block diagram of a system for performing the method of the invention.

FIG. 7 is a logic flow diagram of the example method of the invention of FIGS. 7-9, FIG.

FIG. 8 is a logic flow diagram of the example method of the invention of FIGS. 7-9, FIG.

FIG. 9 is a logic flow diagram of the example method of the invention of FIGS. 7-9, FIG.

[Explanation of symbols]

10 Management Computer 16 Memory 18 PSM Object 22 Peripheral Device 1 24 Peripheral Device 2 26 Management Interface (MI) 33 Managed Entity Object (M
E) 34 Explorer object 36 View object 38 Operation object 40 Database object

Claims (1)

[Claims] 1. A method for enabling a user at a management computer to view information regarding the functions of a plurality of managed units of a peripheral system, wherein each managed unit includes one or more client units. Providing one or more services for the computer, each of the services having an associated managed entity (ME) interface that includes a reference to one or more management interfaces (MIs), and MI
Including one or more methods that provide information about the capabilities of the service associated with the ME,
Executing a view object in response to a user selecting a view object having a function capable of displaying information about a service performed by one or more of the managed units; The view object: (i) which ME associated with the managed unit sends information about the service by invoking execution of the management interface provider object of each managed unit and returning an answer to the associated ME. Deciding whether to provide; and (ii) passing the list of MEs determined to provide the information in step (i) to a further object whose task is to retrieve the information, so that each ME Displaying the information for ) Causing the further object to execute to execute a management interface object at a managed unit associated with each of the MEs on the list, and the management interface object retrieves and returns the information for display to the user; And displaying the information for presentation to a user.