Managing computer network resources

Software agents are assigned goals in accordance with network policies that define a desired operational characteristic of a computer network. A software agent achieves its assigned goal by executing a predefined task. An assigned goal may be dynamically modified as necessary based on the actual operational characteristics of the network. The software agent may request further policy if it cannot achieve its assigned goal by performing the predefined task.

FIELD OF THE INVENTION

This invention relates to computer networks. In particular, it relates to the management of computer networks.

BACKGROUND

Computer networks need to be constantly managed in order to ensure smooth and efficient operation. Such management typically includes ensuring robustness (i.e. the ability of the network to continue operating even if nodes fail), quality of service (QoS), scalability (i.e. the network must operate regardless of the number of nodes), etc.

Typically, network management is performed by humans or is, to a large extent, dependent on human input. This is undesirable, particularly, for example, in the case of a network having a large number of nodes because of the time it would take a human to identify and fix a failed node.

It is therefore desirable that networks run themselves as much as possible.

DETAILED DESCRIPTION

The invention pertains to the management of computer networks. According to one embodiment of the invention, a method of managing a computer network uses software agents. The software agents operate within an agent runtime environment (hereinafter referred to as an “ARE”) which is hosted on a particular network (host) device. Each ARE allows agents operating therein to communicate with the host device, with other agents, and with an agent control mechanism. Each agent has at least one assigned goal which is expressed in the form of policy and which can be dynamically modified based on desired operational characteristics of the network.

System Overview

FIG. 1shows a schematic drawing of a system10for managing a network in accordance with the invention. The system10is vertically layered comprising an ARE12which is loaded on a host platform14defined on a network device. Operating within the ARE12are a number of agents. As will be described in greater detail below, agents may perform discovery, monitoring, and policy enforcement functions. The upper most layer of the system10is occupied by an agent control mechanism16which comprises a CCE+layer18sitting on top of a CCE−layer20(CCE denotes a coherent computing entity). The CCE+layer18defines a global system actuator comprising a Global Agent Repository and Dispatch Module18.1, a Global Domain Policy Store Module18.2, a Policy Authoring Tools and Policy Test Module18.3and a Modeler Module18.4. The CCE−20defines a distributed/localized system observer comprising a Local Agent Repository and Dispatch Module20.1, a Local Domain Policy Store Module20.2, a Local Domain Policy Request Module20.3and Local Agent State Manager Module20.4.

Each layer of the system10masks the complexity of the layers below it and may be configured to provide guaranteed services to the layers above it. Thus, at one level, the system10may be viewed as a macro-quality of service (QoS) infrastructure with the host platform14defining a micro QoS infrastructure.

Typically, the system10is implemented on a large network comprising a number of network devices, each hosting an ARE. The AREs are able to create/instantiate, suspend operation of the agents, and terminate the agents. Each agent has one, or more, assigned goal which is expressed in the form of policy. The module18provides a user interface, preferably in the form of a Graphical User Interface (GUI) which allows policy to be input and stored in module18.2. Policy may be seen as the desired operational characteristics of a network on which system10is installed. Alternatively, policy may take the form of a Service Level Agreement (SLA) which is a documented result of a negotiation between a customer/client and a service provider, that specifies the levels of availability, serviceability, performance, operation or other attributes of the service being provided using the network. Once policy is input into the CCE+18it is disseminated through the various layers until it reaches the various agents seized with the task of implementing policy.

The system10is dynamic in that the agents monitor various operational characteristics of the network devices and report these characteristics to the

CCE+18. This information is used by the global modeler module18.4to model network behavior. The module18.3allows test policy to be written and the effects of such test policy on the system10may be determined by using numerical modeling techniques in the module18.4. In this way, policy may be tested before implementation in order to determine optimal policy. The policy being implemented by the various agents may then be replaced dynamically with the optimal policy. The module18.1maintains a registry of all agents in the system10.

Because the network on which the system10is installed may be large, it is preferable to divide the network into a number of functional/management domains. For example, the various departments of a company may each form a functional domain, or discrete business units may represent functional domains. The CCE−20may be viewed as a control mechanism for a particular functional domain. Accordingly, the Local Agent Reporting and Dispatch Module20.1maintains a registry of all agents in a particular functional domain. The relevant policy is stored in module20.2. Module20.3allows the CCE−20to request domain specific policy from the CCE+18where appropriate. The module20.4stores the state of each agent within a functional domain. The state of an agent may be active or passive. Each device within a functional domain has a domain adapter15which facilitates communications between the CCE−20and the AREs in a particular functional domain.

The system10further includes a secure messaging service/subsystem which will be described in detail below.

In terms of the mechanics of policy handling and distribution within the system10, the CCE+18may be regarded as a global modeler, the CCE−20as a regional modeler, and the combination of each domain adapter15and its associated ARE12as a local modeler as discussed below. As will be described in greater detail below, agents are used to monitor various operational parameters of the system10and to apply corrective policy to change these operational parameters should they deviate from established limits. For example, suppose that a particular network device has deviated outside its normal operational parameters. In this case an agent seized with the task of controlling this device will first determine whether it has the necessary corrective policy to change the operational parameters of the device. If the agent has the necessary corrective policy then it will apply it to control the device. However, if the agent lacks the corrective policy then it will request the corrective policy from the particular ARE within which it is operating. If this ARE does not have the corrective policy then an attempt will be made to obtain the corrective policy from other agents and AREs operating within the particular functional domain. Should this prove unsuccessful then a request will be made to the CCE−20for the corrective policy. The CCE−20will respond by either supplying the corrective policy to the agent or it would obtain the corrective policy from the CCE+18, if it does not have the corrective policy. Thus, it will be seen that system10implements a competence based control flow mechanism wherein, in responding to a situation which requires corrective action, an agent will first attempt to take the appropriate corrective action, should it have the appropriate corrective policy. If the agent lacks the corrective policy it will request it from its host ARE, or other agents within its functional domain, or the CCE−20, or the CCE+18, as the case may be, and in the particular order as recited above.

Advantageously, the present invention may be employed in a wide variety of network applications. For example, the present invention may be used to implement self-stabilizing networks, or to perform load balancing, etc.

The various components of the system10are now described in greater detail.

The ARE

Each ARE12provides an open architectural framework or shell into which existing policies may be plugged by a network administrator, depending on the functional domain under consideration. In various embodiments an ARE12is implemented as a Java Virtual Machine (JVM) or an Object Request Broker (ORB), or as a vendor specific interface which lacks the capacity to host an ARE. Equally, an ARE12may be implemented using remote procedure calls in a Common Object Request Broker Architecture (CORBA) framework. In some cases a host device may be unable to support an ARE or an agent running on it. In these cases, the nearest ARE, defined as the ARE with which the shortest communication path may be established, is used to provide a proxy for that host device. A particular advantage of the present invention is that it is able to lever a JVM and/or ORB to provide an environment in which the agents can operate independently of the underlying hardware and operating system in which the ARE is located. Each ARE12provides a uniform context and set of services that agents can rely on, thereby acting as an operating system for the agents.

FIG. 2shows a schematic representation of the components of an ARE12hosted on a host device30. Running within ARE12are a number of agents13. As can be seen, the host device30includes host hardware32which is the physical platform on which the ARE12is hosted. The host device30may be a computer, a switch, a router, a server, etc. According to one embodiment of the invention, the ARE12is written in C but is wrapped in Java in order to allow it to run on a Java Virtual Machine (JVM)14. This allows the ARE12to run on a variety of hardware and operating systems without having to be customized for each physical combination of platform and operating system.

Reference numeral17indicates system resources which are available to the ARE12and agents13. Typically, the system resources17may include firewall systems, network interface cards, routing planes, network processors, and the like. The ARE12further includes a set of service libraries12.1which provides the agents with access to common services such as a messaging subsystem, class loader, etc. These services will be described below. The ARE12also includes a device adaptor12.2which provides a generalized interface to a variety of device types. While the service library12.1provide interfaces to common services such as a communication layer which is available on each host device, the device adaptor12.2provides an interface to host-specific resources, such as a network forwarding plane. Each host device30has its own version of a device adaptor12.2which configures a generalized device interface to specific commands needed for that particular device.

The ARE12further includes a security manager12.3which controls agent access to the service libraries12.1and the device adaptor12.2. The security manager12.3ensures that resources are only used by authorized agents. Additionally, the security manager limits the rate at which particular agents may use a resource.

It is possible that more than one ARE12may run on a single host device, as is shown inFIG. 3in which ARE12A and12B are shown installed on a JVM14which is running on a host device. The ARE12A has a unique ID which is used to identify and reference it to policies that are to be enforced on the network. Each ARE12A,12B has a unique communications port ID assigned to it. Port assignments for AREs are configurable by command line arguments or system boot configuration files. The command line arguments or system boot files may be in the same format.

Policy changes are monitored by the agents13which listen on port ranges which are also dynamically controlled. The security manager12.3is responsible for encryption/decryption of secured connections within the system10. Each ARE12uses a cryptographic subsystem which may be selected by a system administrator using a configuration manager or a configuration file loaded locally on an ARE12.

ARE-to-agent, agent-to-agent, and ARE-to-ARE communication is performed via a messaging service. The messaging service assumes that both the agents and the AREs are able to decipher the messages that are addressed to it. Details of the messaging service are provided later.

As part of the service libraries12.1, each ARE12supplies to each of its agents a set of utility classes which are usable by the agents running on the specific ARE12. However, before using the utility classes, an agent is required to have permission from the security manager12.3.

Each ARE12facilitates initialization of the agents13by running an auto configuration discovery process. This process requires each ARE to broadcast (upon its startup) a registration request to a topology service (which will be described in detail below) which responds to the request with the necessary information for the ARE to communicate with a network configuration server, policy server, etc. (as will be described in greater detail below).

Each ARE12is responsible for locating a route to various topology servers running the topology service via a multicast boot configuration service. This service provides information on how to find critical services required to operate an ARE.

FIG. 4shows a flow chart of a startup method for an ARE12. The startup method is executed by the device hosting the ARE12. Referring toFIG. 4, at block40an ARE12configures a logging process used to log system messages, errors, etc. At block42, the ARE checks for a Startup Agent List which is a list of agents, such as may be provided on the command line to the ARE at startup. If such a list exists, agents on the list are started one at a time by executing a start-agent process which includes a loop comprising starting an agent at block46and checking for another agent in the list at block44until all agents in the list have been started. If no Startup Agent List exists, the ARE assumes it is to run in a stand-alone mode i.e. the ARE assumes that network resources are unavailable and sets itself up to run autonomously. At block48the ARE broadcasts a multi-cast registration message to any topology server to register itself and obtain messaging information necessary to communicate with the configuration manager. This broadcast includes the ID of the particular ARE, the network address of the host machine on which the ARE is running, and the port number used for communications by the ARE. At block50the ARE checks to see if it has received a Startup Reply from a topology server. If no Startup Reply is received, at block58a check is performed to see if a predetermined time within which the Startup Reply is expected has expired. If a Startup Reply is received, at block52a determination is made as to whether the reply includes a Startup Agent List. If it does, a loop is entered comprising starting an agent at block56and rechecking the list at block54until all agents in the list have been started. If at block58the predetermined time has not expired, at block60the ARE waits or sleeps for the unexpired portion of the predetermined time. If the predetermined time has expired, at block62a check is performed to see if a predetermined maximum number of broadcast retries have been exceeded. If not, block48is re-executed. If the predetermined maximum number of broadcast retries has been exceeded, at block64the ARE listens for messages. At block66, the ARE determines whether a received message is a Shutdown message. If the received message is a Shutdown message, at block68the ARE shuts itself down; otherwise, at block70the ARE processes the message and repeats the process starting at block64.

The processing represented by block70includes:

(a) maintaining a list of all internal resources and services available to it and the agents operating within. This includes all agents that are currently running, proxied, or suspended;

(b) keeping a systems history log for each agent started;

(c) routing messages to and from agents it hosts. Each ARE2understands when an agent is referring to a local external agent residing on another host as opposed to an agent already running in the ARE12. Accordingly, each ARE knows how to route messages between the various agents;

(d) performing start-up services required for proper agent operation prior to loading/instantiating/running any policy agent (as will be described below);

(e) starting the necessary agents and services upon a request from an authorized local or external agent requiring it to instantiate a particular agent not already instantiated. The particular ARE in which the requesting agent is running performs a check via its security manager to see if the requesting agent has permission to access this type of agent/service on either the current ARE or on a remote ARE;

(f) keeping a master thread group that starts, stops and resets agents within its control;

(g) requesting other external thread groups on other AREs to start, stop and reset proxied agents only if they have the appropriate authorization. A master thread group within each ARE12has the ability to control the priority of each agent in a thread group. This priority is set by the master thread group depending on the type of agent being run and the policies being enforced by that agent. The master thread group starts up everything within an ARE. This means that all agents and services started within the ARE are boot strapped using the master thread group. The master thread group will pass into each thread group standard environmental settings to run within the thread group—Thread utilization is administered by a subsystem called a proxy thread manager not shown that acts as a thread controller and mediator for interaction between agents and threads. Each agent can be pacified, by the proxy thread manager, and it's thread made available to active agents in the event of such pacification. In other instances agents can simply return a quiet thread to the proxy thread manager pool for use by other agents; and

(h) suspending an agent after the agent has registered itself with the ARE, in order to conserve thread and resource usage since an agent does not need to be active until required, and reinstating the agent when the agent's services are required.

FIG. 5shows a flowchart of an agent startup process executed by an ARE. In one embodiment the agents are defined by agent code written in Java, wherein the Class construct in Java is used to define an Agent Class. Referring toFIG. 5, at block80, the AREs12load the agent code, and any code the agent code is dependent on, into memory. During loading and at block82, the security manager12.3verifies that access to the agent code is allowed. If the ARE does not have permission to access the agent code, or other code on which the agent code is dependent, then a security error is generated at block84and the ARE12logs an agent load failure. If no security error is generated, at block86an agent initialization process is called prior to calling an execution process. The agent initialization process allows any initialization tasks to be completed before execution of the agent code begins. Error messages generated during agent initialization is detected at block88and at block84an agent initialization failure is logged. If no error messages are generated during agent initialization at block90, the ARE12allocates a new thread of execution for an agent and executes a threat-start process, which executes the agent code. Each agent executes its own thread, which is separate from the main thread of the ARE and any other agents. At block92the agent is added to a registration table in the ARE12.

The process of shutting down an ARE is shown inFIG. 6. Referring toFIG. 6, at block100a check is performed to see if there are any agents left in the registration table. If no agents are left the agent shutdown process is complete and the ARE terminates. Otherwise, at block102an agent stop process is called which stops execution of agents. At block104details of the agent whose execution was stopped are removed from the registration table. Returning at block100, the shutdown process is repeated until there are no agents left in the registration table.

Agents

As used herein the term “agent” denotes a program that performs some type of operation, which may be information gathering or some processing task, in the background. A foreground process is one that accepts input from a keyboard, mouse, or other input device whereas a background process cannot accept interactive input from a user, but can access data stored on a disk and write data to a display. In particular, a software agent is a virtual entity which: (a) is capable of acting in a runtime environment; (b) can communicate directly with other agents (messaging); (c) is driven by a set of tendencies (expressed in the form of individual objectives or of a satisfaction/survival function which it tries to optimize or policy); (d) possesses resources of its own (logic and algorithms); (e) is capable of perceiving its environment (state); (f) has only a partial representation of its environment; and (g) is able to reproduce/clone itself,

An agent tends to satisfy its policy directives taking account of the resources and logic available to it, and depending on its perception of its state, its representations, and the communications it receives.

According to embodiments of the invention, agents may be simple (or static and narrow in scope). Alternatively an agent may be complex (mobile, intelligent and autonomous). A simple or static agent is one which is always located in a particular ARE. In other words, it is static within the environment of the ARE. On the other hand, a complex or mobile agent is one which is trusted to migrate to other AREs hosted by other network devices.

According to embodiments of the invention, agents may be autonomous and/or intelligent. Both intelligent and autonomous agents have a degree of sophistication which allows them to algorithmically interpret the state of their environment and to perform tasks independently without human interaction. They possess representations of their environment and inference mechanisms which allow them to function independently of other agents. The difference between intelligent and autonomous agents lies in the scope of the representation of the environment that they possess, an intelligent agent having a greater representation of its environment than an autonomous agent. Accordingly, an intelligent agent is able to solve complex problems without reference to outside entities whereas as an autonomous agent is able to independently solve complex problems up to a certain level beyond which the autonomous agent will have to request further policy or data from an outside entity such as the agent control mechanism16ofFIG. 1.

As discussed above, mobile agents can migrate under their own control from machine to machine in a heterogonous network. However, mobile agents cannot act on their own on any platform without external activation messages. In other words, a mobile agent can suspend its execution at any arbitrary point, move to another machine and resume execution there only after receiving a dispatch message from the agent control mechanism16. The primary reason for this is that a mobile agent is not provisioned to act upon its new environment and must thus wait for the necessary algorithms and logic to be received before migrating.

As will be appreciated, mobility is a powerful attribute for an agent as it allows an agent to perform tasks such as information gathering in a network which includes a distributed collection of information resources. Further, by being able to migrate to a particular network location, a mobile agent eliminates all intermediate data transfer and can access a resource efficiently even if the resource provides only low level primitives for working within it. This is beneficial, particularly in a low bandwidth network where instead of moving the data to a computational resource it is more practical to move the computational resource to the data.

Mobile intelligent agents are able to migrate under their own control from machine to machine in a heterogonous network without waiting for external activation messages.

A further attribute of intelligent and autonomous agents is that they have the capacity to anticipate future events and to prepare for them. These agents are able to use a capacity for algorithmically induced reasoning based on representations of the environment to memorize situational parameters (data points), analyze them, and request additional algorithmic components (policy from the agent control mechanism). In the event that there is a conflict in goals between these agents, these agents are able to negotiate among themselves to determine which goals/policy are more relevant to satisfy needs.

Agent Structure

FIG. 7shows the broad generic structure of an agent110according to one embodiment of the invention. The agent110includes a messaging adapter112which provides the functionality of sending messages to and receiving messages from other agents, AREs and components of the agent control mechanism16. Sending messages is a specific type of action for which there is policy. On the other hand, receiving messages is implemented as a sensing process which models a receive-queue.

The messaging adaptor112may be implemented, for example, using the Transport Layer Security (TLS) protocol. One advantage of TLS is that it is application protocol independent. Higher level protocols can layer on top of the TLS Protocol transparently.

The agent110further includes a policy repository114which contains agent specific policy that is necessary for the operation of the agent110. This policy is obtained from the policy stores of the CCE+18and the CCE−20.

The policy repository114of agent110may be implemented using a Lightweight Directory Access Protocol well-known (LDAP) directory structure. LDAP uses LDAP directories to implement Public Key Infrastructure (PKI) security. From a user's point of view, LDAP provides the directory in which the certificates of other users are found, enabling secure communication. From an administrator's point of view, LDAP directories are the way in which certificates can be centrally deployed and managed.

Alternatively, a Policy Knowledge Base (PKB) model may be used. PKB policy reporting offers three types of interface services: assertional services, retrieval services, and active information services. Assertional services allow agents to assert new beliefs (policy) into the knowledge base, (i.e., to create instances of policy, and to change the values of attributes of existing policy instances). Retrieval services provide access to policy that is actually stored in the agent knowledge base. Active information services offer access to information in the knowledge base upon demand. Requesting an active information service starts a monitoring process that recognizes specific changes in the knowledge base and sends information about these changes to the requesting process, i.e., to specific control layers.

The agent110further includes a policy repository116. In one embodiment all agents are instances of an Agent Class described in Java. A number of methods are written for the Agent Class to add functionality to agents based on the policy the agent is required to implement. The method repository116is a store of all such methods for an agent110.

The agent110further includes a control unit118. The control unit118executes policy using relevant methods from the policy repository116to calibrate, execute, activate, respond and deactivate specific actions based on policy.

Atomic actions are actions whose execution is started and then either succeeds or fails. The execution of continuous actions initiates a control process which will run until explicitly finished, suspended, or deactivated. Examples of these types of actions are actions such as activating a control algorithm to make a router shut down a port upon detecting attack.

Included in the agent control unit118is a method requestor/dispatcher which is defined by a generic “Layer” object. The main method of the Layer Object describes a “sense-recognize-classify-invoke method” cycle. In each loop of this cycle the current policies of the agent110are scanned for new relevant situations relative to a current system state. These situations, together with the messages received from the next lower layer (which defines the domain adapters15) are used to compute new options for the agent110. These options are then passed to the CCE−20(or CCE+18if necessary), which is responsible for making decisions (i.e., for selecting appropriate operational primitives and for updating the policy structure) and for scheduling and executing those decisions which are expressed in the form of new policy. In particular, this mechanism decides whether a layer will deal with a specific goal problem by itself, or whether it will pass the goal up to the next higher control layer. In the former case, the layer decides what new policy to make in order to achieve the goal and schedules the new policy for execution. The execution of new policy is linked to the situation recognition process: when an action is executed, a reactor is activated which monitors the expected effects of the action.

The fundamental activity cycle comprises updating policy, situation recognition, goal activation, a generation of situation-goal pairs as input a planning, scheduling, and execution process, a competence check including the set of situations and goals into a subset for which the layer is competent and for which plans are generated and executed by the layer, and into another set for which the layer is not competent, and for which control is shifted to the next higher layer.

As shown inFIG. 7, agent110communicates with a domain adapter115which may be represented as an object providing methods for sensor calibration, enabling and disabling sensor activity, and for reading current values relevant to the respective domain.

Current sensory values are made available to the agent control unit118by a perception buffer from which the values of sensors can be read, and which can be explicitly updated. The perception buffer itself calls the methods offered by the individual sensors, e.g., in order to read the current sensory information.

There is a flow of information between the policy repository114and the AREs, the CCE−20, and the CCE+18. New policy derived from an agent's perception is sent to the CCE−20and entered into a PKB located in the Local Domain Policy Store20.2. In the event the CCE+18determines that an ARE operating within its functional domain needs to be provisioned with a new policy, it “pushes” to a PKB in the relevant ARE which then “pushes” the new policy to specific agents if necessary.

Each agent control unit118continuously accesses information from the repository114. The situation recognition processes at the different layers of system10evaluates environmental parameters in order to determine whether new policy is required. This involves a planning process which evaluates preconditions of actions.

According to other embodiments of the invention, an agent control unit118may modify the policy repository114by signaling first to its associated ARE, and subsequently to the CCE−20, a demand for new policies. The derivation of new policy, which is known as knowledge abstraction may be anchored either in the PKB or in the control unit of the agent. The former alternative describes the knowledge base of an agent as an active, blackboard-like system, whereas the latter alternative corresponds to the view of a classic Artificial Intelligence (AI) planning system. The performed alternative depends on the power of the inferential services provided by the knowledge base in repository114.

General Characteristics of Agents

As will be appreciated various implementations of the agents are possible, however each of the agents will have the following general characteristics:

(a) agents assume a secured environment already exists wherever they run (there is only one Security Manager per ARE);

(b) each agent assumes certain services (such as a Logging Component, Security Manager, Device Adaptor, class loader, etc . . . ) are available to it from the ARE.

(c) agents assume there is a (limited) statically defined relationship hierarchy between other agents at runtime which are defined in part by the messaging service, modelers, policies, and a topology service;

(d) agents assume that all system resources are freely available and if a resource is available to an agent, the agent has permission to use the resource unless otherwise restricted by the security manager12.3;

(e) each agent has a unique ID within the ARE in which it operates and which, when coupled with the ARE's unique ID, defines a unique agent name; a Globally Unique ID (GUID) generator generates an Agents unique ID.

(f) each agent maintains information regarding its management status and the management domain under which it is being administered;

(g) an agent's management domain state may be defined in one of three ways, viz. Controlling, Subordinate, or Not Applicable (NA). With Controlling, the agent acts as a Policy Decision Point (PDP) i.e. a logical entity that makes policy decisions for itself or for other network elements that request such decisions. With Subordinate, the agent refers the policy decision point to another agent. With Not Applicable, the agent ignores any policy decision requests made to it by the system10;

(h) each agent is assigned a named thread group upon creation;

(i) each agent is passed shared variables used to facilitate Inter-Process Communications (IPC) messaging transfer between a master message queue and each agent's message queue;

(j) each agent upon instantiation is assigned a thread priority level by the ARE, which will be determined by policy and agent class type being instantiated;

(k) agents register with the local ARE when instantiated; and

(l) agents have the ability to be passivated and/or re-activated by the ARE.

As discussed above each ARE has the ability to provide feedback on the per-thread utilization of each thread running within it. This information is used by the CCE−20to, for example, help determine load balancing on the ARE's.

Agent Behavior

Agents are used to enforce specific actions/behavior on hardware/software devices controlled by the system10. Agents have both a policy-enforcement-point (PEP) i.e. a logical entity that enforces policy decisions, and a policy-decision-point (PDP) aspect. In combination with the local modelers, each agent may be viewed as a PDP. Agents use an event notification system whereby policies are setup as alerts to be monitored within the local modelers, which notifies the appropriate agents that a policy SLA is not within its desired operational range. Agents use a two stage feedback mechanism, which links the local modelers to the agents to provide the alert notification feedback loop required to monitor device/application evaluation and administer corrective actions within the network for a given network state.

Agents depend on each ARE to route messages within an ARE to other agents either within the same ARE or on other AREs, which can be either running on either the same or different machine. Agents are able to request both local and remote network resources that are registered within an ARE. Agents rely on their associated local modelers to replicate fault tolerance behavior and state information to other local modelers running on different machines. This is used in conjunction with the topology service to replicate state across the functional domains of system10.

When agents initialize, they register themselves with their associated ARE and local modeler. Each agent registers its policy/SLA requirements. The local modeler then sets up a listener to listen for a particular polling agents ID, and relays its feedback information with the local modeler. The agent's action commands are called by the local modeler when information from a monitoring agent indicates the agent's policy/SLA is no longer within its operational range.

Agents in conjunction with the associated local modelers set up feedback processing loops to monitor policy within the device being controlled.

In order for an agent to implement policy it may need to request services that are not currently running or loaded on the local ARE host. If the local ARE cannot support such an agent request, a request to the topology service is made to find a remote ARE that is either running or can run the required service. If the security check passes for the requesting service, the service is either started on the remote ARE or the ARE attaches to the existing remote service. The remote ARE then proxies back the service to the local ARE requesting the service. If the requesting service cannot be started anywhere within the system10, the agent sends back an exception indicating the required service could not be started. This exception is sent along a system alert handling interface developed for the AREs.

When an agent loads a device adapter, it makes a security access call to verify that (a) the classes or libraries needed to communicate and control the device to be managed haven't been altered and (b) the agent's device adapter has rights to resources the classes and libraries are accessing.

The means of communication between ARE-to-Agents, Agent-to-Agent, and ARE-to-ARE is the messaging service. Each sending agent has to determine if a receiving agent is receiving and acknowledging the sending agent's request.

Once the agents have set up the initial policies and configurations they are then passivated by the ARE (i.e. the agent's thread is suspended) so as to conserve resources within the ARE.

Having broadly described generic agents in the system10, specific embodiments of agents will now be described.

Discovery Agents

The system10includes discovery agents which are used to examine and determine the capability of a network device (host) and the equipment or components of the device. Each discovery agent then reports this information to a topology server so that the system10can use the information to construct a topological representation of the network.

A simple or static discovery agent might, for example, simply start executing when a device is first powered up and thereafter will look for any new device components or changes in capability to existing components, report the information to the topology server and thereafter terminate. This allows the system10to know about equipment changes, such as the adding of a new processor, more memory, or a larger disk to a device. Discovery agents may be written to check for new components or capabilities deemed important to the operation of the devices.

The life cycle of a simple discovery agent is shown inFIG. 8. Referring toFIG. 8, at130a configure logging process is performed. At132the discovery agent performs the discovery process. At134the agent reports the discovered configuration to a topology server and at136the discovery agent unregisters the ARE.

Policy Agents

The system10also includes policy agents which are used to enforce or implement specific policy. Policies defined in the system10are parsed by a policy agent and the agent configures/controls a device in order to enforce the desired policy. Policy enforcement often involves configuring a device to behave in a specific way and thereafter simply letting the device operate. However, policies may be more complex and may require dynamic control of a device. Policy agents operate on local devices (devices running an ARE in which the policy agent is executing) or remote devices (devices which cannot run an ARE for agents to execute in).

FIG. 9shows a lifecycle of a simple policy agent, which configures a device and thereafter lets the device run. Referring toFIG. 9, at140a configure logging process is performed. At142the policy agent requests or receives policy parameters from a policy server. Thereafter at144a determination is made as to whether the parameters have been received. At146if the parameters have been received then the device is configured to operate in accordance with the policy parameters. If no policy parameters are received or after step146has been performed, then at step148the policy agent unregisters from the ARE.

FIG. 10shows a flowchart of a more complex policy agent which works in conjunction with monitoring agents (see below) and other policy agents. This type of policy agent continuously monitors for feedback from monitoring agents and adjusts the policy enforcement settings for a device based on such feedback. Referring toFIG. 10, at150a configure logging process is performed. At152the agent requests/receives policy parameters from a policy server. At154a determination is made as to whether the policy parameters have been received. If the parameters have been received then at156the agent configures the device to operate in accordance with the policy parameters. Thereafter, at158the agent listens for messages from a monitoring agent and at160a received message is parsed to check if it is an agent shutdown message. If it is a shutdown message then at164the agent is unregistered from the ARE. If the message is not a shutdown message then it may be a new policy or “monitor results” message which is parsed at162and step156comprising configuring the device in accordance with the new policy parameters is performed.

Thus, the complex policy agent goes beyond configuring a device and letting it run and adds a level of dynamic control at the policy enforcement point. The policy agent code itself can become part of the operating policy, shifting between specified policy enforcement settings based on the observed dynamics of a network as reported by associated monitoring agents.

Monitoring Agents

The system10further includes monitoring agents to monitor various aspects of the devices in the network. Monitoring agents are able to monitor local devices (i.e. devices running an ARE in which the monitoring agent is executing) or remote devices (i.e. devices which are not able to run an ARE). Each monitoring agent has monitoring policy which determines the operation or set of operations it should perform to monitor the device, and a set of thresholds, within which the monitoring results should fall. When monitoring results are found to lie outside the specified threshold range, the monitoring agents report the event to the system10. Complex monitoring agents may be written to combine monitored values in a variety of ways using threshold ranges, time periods, rates of change, etc. A hierarchy of monitoring agents can also be used in order to monitor inter-dependent devices, or a sequence/path of devices.

A typical monitoring agent has a lifecycle with a flow of execution similar to that shown inFIG. 11. Referring toFIG. 11, at170a configure logging process is performed. At172, the monitoring agent requests/receives monitoring parameters from a configuration manager. At174a determination is made as to whether or not the monitoring parameters have been received. If the parameters have been received then at176the monitoring agent performs the monitoring operation. Thereafter, at178a determination is made as to whether the monitoring results lie outside a specified threshold. If the results lie outside the threshold then at180this is reported to a policy agent and/or CCE−20(see below). If the monitored results fall within the specified threshold then at182the monitoring agent sleeps or lies dormant for a specified time (based on a monitoring frequency) after which, at184a check is performed to see if new monitoring parameters have been received in the form of a new message. Depending on the results of the check, step176may be performed again. At186a determination is made as to whether the new message is a message to shutdown the monitoring agent. If the message is a shutdown message then at188the monitoring agent unregisters from the ARE.

Detailed Description of Device Adapter Interface12.2

Each device adapter12.2defines a boundary that separates generic system calls from device specific functional calls made upon a particular device(s)/application(s). Both the policy agents and the monitoring agents may make calls to a device adapter12.2provided that the functionality of the command and control and monitoring feature sets do not overlap. Each device adapter12.2has two types of API calls for the command and control features. Both generic Traffic Engineering (TE) and Application Engineering (AE) calls are used to control devices and applications within the system10. Each device adapter12.2includes device specific drivers which are loadable and unloadable at runtime.

In use, the device adapters “Ping” a device and maintain an open communications channel with the device to make sure a connection with the device does not time out. Monitoring agents are used to achieve this.

Appropriate classes or components needed in order to implement a policy-configuration described within a policy are loaded into each device adapter12.2at runtime. Each device adapter12.2has a command that signals to the device the device adapter is ready to initiate a device command sequence and a command used to signal to the device the device adapter has finished a device command sequence.

At any point in a communication between a device adapter12.2and a device to be managed, an agent may restart and reload class or library drivers to passivate, then reactivate, the connection between the device adapter and the device. In response to an agent request to reactivate the connection, the device adapter12.2internally calls a process which passivates communication between the device adapter and the device and process which resets the device adapter.

An agent may query the device that is being managed by a device adapter12.2to obtain the current device state depending on what the lag time is between requesting the information from the device and actually receiving it. The agent requesting the information will get different degrees of information back depending on the device information calling level requested. The calls made between each device adapter and the device being managed are preferably secure calls.

Each device adapter12.2includes a device adapter toolkit comprising a Command and Control API interface and reference implementations of a Hyper Text Transfer Protocol (HTTP), Simple Network Management Protocol (SNMP), Secure Shell (SSH), and a plain-text device adapter. The device adapter toolkit provides a general interface for management functions used to control host devices.

According to one embodiment of the invention, monitoring agent API calls are designed to setup feedback loops between a monitoring agent and a device or application which facilitates monitoring compliance with policy within the system10.

The monitoring agent API assumes there will be some lowest common denominator of communication used for each type of device monitored, be it hardware or software. An example would be to use the SNMP protocol for hardware/software devices. Alternatively, a software solution in which an SNMP library is compiled into the application may be used.

There are four types of monitoring within the system10. These are active (push), active (pull), passive (pull), and passive proxy monitoring.

With active (push) monitoring a device or application would actively broadcast or send information regarding its state to other system10components. In one embodiment of the invention, a call is made to a device to startup an application loaded therein which would begin the broadcast which is received and understood by a monitoring agent. Thus, there is an active agent running on the device sending information out in a controlled and timely manner.

With active (pull) monitoring, the agent itself is not passivated and continues to make request/response types of communication between the device adapter and the device/application to be monitored.

With passive (pull), the monitoring agent listens for SNMP traps from a particular device(s). The monitoring agent does not actively setup a feedback loop.

With passive-proxy monitoring, a monitoring agent acts through non-direct means to garner information about the device and its statistics by interrogating neighboring devices.

Each monitoring agent connection has two or more parties involved in each feedback loop between a device192and application194as can be seen fromFIG. 12A. The monitoring agents are referred to as listeners190and the device192/application194sending the feedback information is referred to as a sender. There can be more than one listener listening to a sender's transmission i.e. there is a many-to-one relationship between the listener and a sender.

Each monitoring agent creates the feedback loop and as already described has the ability to alert the local modelers to monitored responses. These responses are called policy events and are used to detect any aberrant behavior based on operational ranges specified by the policy. Each local modeler has the ability to take immediate corrective action.

Each device within the system10accommodates a minimal set of feedback API's. Devices not able to accommodate this set can be proxied by the device adapter (Listener) into a request/response type of arrangement. This implies there is at least some means of querying the device to be monitored. An example is a device that has a simple web server request/response interface built into it. In rare instances, a device may not be capable of any direct response. If this should arise, the measurement may be inferred through indirect measurement by a proxied device. Sampled feedback API calls include createListener( ); createSender( ); startListener( ); startSender( ); stopSender( ); resetListener( ); and resetSender( ), all of which are methods in Java according to one embodiment of the invention.

According to one embodiment of the invention, in setting up a feedback loop between the device adapter and a device/application, the monitoring agent assumes the device has an active agent running upon it which sends out information to its associated local modeler. According to another embodiment, it is assumed that the device adapter has the capacity to talk to the device in question using the request/response metaphor to glean information from the monitored device. This information is then intercepted and sent to the relevant local modeler. According to yet another embodiment, where there are no active senders (code) on the device/application side, information is inferred by looking at various devices that have active and request/response capabilities around the device to be monitored. By looking at information going into and out of devices that surround the device that is being monitored, information about said device may be inferred. This embodiment is shown inFIG. 12Bof the drawings. Referring toFIG. 12B, the various devices around the device to be monitored function as a proxy sender196, which provides feedback messages to a listener/monitoring agent190. The feedback is based on communication between an application194and a device192.

The protocol used to setup the feedback loop is dependent on the device adapter12.2and the method used by the device adapter12.2to communicate with the device/application. The monitoring agent assumes the communication between the device adapter12.2and device is secure and private.

A monitoring agent may monitor more than one feature on a device. The monitoring agent may then aggregate a device's polling attributes together into one larger call.

In some embodiments, the monitoring agents comprise two separate agents running sending information between each other or it may be physically the same monitoring agent acting as both sender/Listener.

Messaging Service

The system10further includes a messaging service which defines a message bus subsystem which facilitates secure communication between the various system10components. The message bus provides for two types of messaging models, publish-and-subscribe and point-to-point queuing, each of which defines a messaging domain.

In the simplest sense, publish-and-subscribe is intended for one-to-many broadcast of messages, while point-to-point is intended for one-to-one delivery of messages.

In a publish-and-subscribe model, one publisher can send a message to many subscribers through a virtual channel called a topic. A topic may be regarded as a mini-message broker that gathers and distributes messages addressed to it. By relying on the topic as an intermediary, message publishers are kept independent of subscribers and vice-versa. A topic automatically adapts as both publishers and subscribers come and go. According to one embodiment of the invention, publishers and subscribers are active when the Java objects that represent them exist. Subscribers are the components which are subscribed to receive messages in a topic. Any messages addressed to a topic are delivered to all the Topic's subscribers. The publish-and-subscribe messaging model defines a “push-based” model, where messages are automatically broadcast to subscribers without them having to request or poll the topic for new messages. In the publish-and-subscribe messaging model the publisher sending the message is not dependent on the subscribers receiving the messages. Optionally, the components that use this model can establish durable subscriptions that allow components to disconnect and later reconnect and collect messages that were published while they were disconnected.

In a point-to-point messaging model components are allowed to send and receive messages synchronously as well as asynchronously via virtual channels known as queues. A queue may have multiple receivers. However, only one receiver may consume each message.

Anatomy of a Message

Each message has two parts comprising: the message data itself, called the payload or message body, and the message headers and properties.

Messages types are defined by the payload they carry. The payload itself may be very structured, as with the StreamMessage and MapMessage objects, or fairly unstructured, as with TextMessages, ObjectMessages, and ByteMessage types (see below). Messages can carry important data or simply serve as notification of events in the system10.

Message headers provide metadata about messages describing who or what created the message, when it was created, how long the data is valid etc. The header also contains routing information that describes the destination of the message (topic or queue), and how a message should be acknowledged.

Each message has a set of standard headers. According to one embodiment, a message header may contain the following fields:

In addition to headers, messages can carry properties that can be defined and set by a message client. Message clients can choose to receive messages based on the value of certain headers and properties, using a special filtering mechanism called a Message Selector (see below).

A message selector allows a component to specify, by message header, the messages it is to receive. Only messages whose headers and properties match the selector are delivered.

Message Bus Structure

The message bus provides a consistent, secured, and stateful/stateless messaging capabilities to the various services and components within the system10. The message bus provides a mechanism that allows messages to be queued between components (State-fullness) and provides a classification mechanism so to allocate priority levels for specific messages. If a component is restarted, the component can request previous messages, so as to get a history and be in synchronization with the rest of the system10.

The message bus supports one-way messaging such as multicast and broadcasts at the socket/port level, in addition to the publish-and-subscribe messaging model.

According to one embodiment of the invention, the message bus listens on specific ports for User Datagram Protocol (UDP), Transmission Control Protocol (TCP/IP), and Internet Inter-ORB Protocol (IIOP) traffic.

The message bus implements a client library that other components compile with to communicate with the publish-and-subscribe or one-way messaging models.

Each message within the message bus has a unique ID, derived in part from the Media Access Control (MAC) address of a network card used by a message bus server.

According to one embodiment of the invention, a message on the message bus has its payload encrypted. The header within the Message Bus message then specifies whether a payload is encrypted or not. To further increase security, the message is sent on multiple ports or channels which are randomly changed.

The header within a message on the message bus contains information regarding a message digest (MD5). The digest is used to verify a message has not been modified during transmission.

The message bus saves its current message state a data storage. This data storage provides persistence and fault-tolerance to the messaging system.

The message bus groups messages together into specific groups (topics).

According to one embodiment of the invention, there is a single root for the message bus which defines a virtual root used to the message bus hierarchy. Each topic then branches off this virtual root.

Message groups (Topics) within the message bus define a hierarchical tree. Topics then may have other topics underneath them as child nodes in the tree.

Message Types

The number of message types that can be defined for use with system10are limitless. However, a few of the message types used in embodiments of system10are described below:

Policy Event messages are used to communicate changes of state within the system10. This type of message is used to transport policies throughout the system10. The Policy Event messages carry within them all the information needed to apply/run a policy on an agent. Policy Event messages have state and are stored and forwarded on to destinations. Policy Event messages assume the message bus guarantees delivery of the message. Policy Event messages have a unique identifier in the system so that the system can be sure that the Policy Event messages sent have not been tampered with. According to one embodiment of the invention, this identifier could be in the form of a digital signature. Policy Event messages are sent in a secured (SSL) manner on message bus according to one embodiment of the invention.

Security Policy Event messages are a subset of the Policy Event message type. This message type deals with security related topics such as authorization/authentication issues between various system components.

Logging Policy Event messages define the logging characteristics of the system10. Logging Policy Event messages can be used for debugging the system10. The Logging Policy Event messages have various warning and error levels defined.

Auditing Policy Event messages define various audit control messages available to the different system10components and device/applications managed by the system10.

Service Management Event messages are used to control various system10services.

Device/Application Management messages are used to control device(s)/application(s) managed by the system10. The way Management messages are sent is dependent on the device or application to which a device adapter12.2is trying to communicate with. Management messages may or may not use the message bus to convey control information to the device or application being managed. Management messages assume communication between a device adapter12.2and the device/application being managed is guaranteed.

Feedback messages are used to provide real-time/near real-time feedback information on a device/application that is being monitored by the system10.

Generic messages are used to convey information outside the normal Message Bus boundaries. These messages are used to communicate with outside systems that require special means (gateways) to communicate between system10and foreign systems. Generic messages have a guaranteed delivery but have no time dependency attached to them.

Message Bus Behavior

A client object using the message bus client library is able to connect to a publish/subscribe channel. The client library provides event handles or thread safe callbacks to the calling program.

The message bus server keeps a log of all transactions/operations that occur regarding message routing within the message bus.

The message bus provides a mechanism that allows a system administrator to direct and define the logging/auditing levels to various components within the system10in real-time.

The message bus server derives a time stamp from a time service. All messages created within the system10derive their time stamp either directly or indirectly from a time server running the time service.

The message bus includes an error reporting mechanism which reports specific error conditions relating to commands and operations carried out by both the client/server side of any message bus operation. Notification of an error condition is provided to the clients and servers.

Errors are logged to a Logging Service, which allows the system administrator to perform a system message audit to determine where the error originally occurred.

The system10includes a Client Plug-in which reside as a Dynamic Link Library (DLL) or in component(s), which install locally on a client's browser.

The client Plug-in is able to retrieve specific information from a digital certificate that uniquely identifies (authenticates) a user using the browser connecting a system10network.

The Client Plug-in is activated when a web server sends a Hypertext Markup Language (HTML) page back to the browser with a special Multipurpose Internet Mail Extensions (MIME) type embedded in an HTML page calling on the plug-in to start on the client's browser.

Users are able to administer a site list using commands such as add, delete, and modify. This allows the user to either add new sites or change Uniform Resource Locator (URL) addresses when necessary.

In one embodiment of the invention, the Client Plug-in will be activated only if there is a secure SSL connection between the user's browser and a host server identified within the site list.

The state information for mapping a certificate to a site (URL) is kept in a secure (encrypted) file locally or is encrypted and stored within the client operating system registry for the browsers plug-in.

Client Plug-in Behavior

If a user is not connected to a system10controlled network, the client plug-in will not be activated.

When visiting specific sites within the plug-in's site map list, the plug-in attaches a serial number, from a user's digital certificate residing on the browser, to the front of an HTTP stream. This is used as a tag or (cookie) to uniquely identify each user within the system10controlled network.

The client browser plug-in activation/request sequence according to one embodiment of the invention will now be described with reference toFIG. 13of the drawings. Referring toFIG. 13of the drawings, at (3) the client browser requests a web page from the server. At (4) if the web page requested is a secure page, the server sends a HTML page with MIME type EMBED to start the Client Plug-in on the client browser. The Client Plug-in then verifies if the connection is over SSL. At (6) the Client Plug-in appends the data read from the certificate (Serial Number) to the HTTP stream and sends the request to the web server (The Netscape function NPN_PostURL method or a cookie may be used to send this information). At (1) A certificate mapper component reads the certificate mapped by the user. At (2) the certificate information required for authentication is extracted and stored in a predefined location. At (3) the client browser makes a request to a secure page on the server. At (4) the server returns an HTML page with the plug-in EMBED to start the plug-in on the client browser. At (5) the plug-in gets the certificate information from the client's machine. At (6) the certificate information and/or data (using PostURL to the server) is returned. Finally, at (7) the server validates the certificate and returns the requested page.

Policy Distribution

Policy is distributed in the system10along a chain defined by the global, regional and the local modelers. The global modeler breaks up and enforces policies upon subordinate modelers. This is done to add scalability and robustness and to reduce decision-making time.

Local modelers typically exist within an ARE. This is done to reduce the footprint of an ARE when memory is in short supply, such as inside a network appliance.

FIG. 14shows a block diagram of an ARE12comprising a local modeler12.4which enforces policy on policy modelers12.5which define the lowest level modeler. The policy modelers12.5reside inside an agent and enforces simply policies.

The modelers apply a policy calculus to decompose policies with simple policies.

Hierarchy Between Modelers

FIG. 15shows the hierarchy of the various modelers within the system10according to one embodiment of the invention. Referring toFIG. 15, the first level is the local level which is defined by local modelers200, such as local modeler12.4inFIG. 14. The local modeler200comprises a number of AREs202which control devices204or applications206. Each ARE communicates to a topology service208. One level above the local level is a regional level which is defined by a regional modeler210which controls a number of local modelers200. The highest level in the system10is the global or enterprise level which defines a global modeler212. The global modeler212communicates with a policy service214, the topology service208, and a configuration service216to coordinate overall policy interaction and control. An administrators GUI218facilitates input to the global modeler212. The administrators GUI218comprises a policy GUI220whereby new policy or policy changes may be input into the system10. The administrators GUI216further comprises a configuration GUI222whereby configuration changes to the system10may be input.

FIG. 16shows the configuration of the various modelers shown inFIG. 15in greater detail. Referring toFIG. 16, a monitoring agent224is started as described earlier. In one embodiment the monitoring agent224has a sender component224.1which sends information about the operation and status of application206and device204, respectively, to a listener component224.2. Such information is in the form of feedback messages. In a second embodiment, information about an application206or device204is obtained indirectly using a proxy sender220.3/listenter224.1variation of a monitoring agent as previously described. As is shown inFIG. 16, the listeners220.1send policy event messages to a controller226. Each of the controllers226is defined by a policy agent/device adapter combination. The controllers222are able to send management messages to the applications206and devices204in order to exert control over these devices and applications. Each of the controllers226communicate with local modelers200by sending and receiving policy event messages. Communication between the local modelers200and a regional modeler210takes place via an exchange of policy event messages. Likewise, policy event messages are exchanged between the regional modeler210and a global modeler212. The global modeler is able to send generic system messages to a system administrator.

Thus, according to the embodiments described above, the local modelers form part of the Policy Decision Point (PDP) for agents and is concerned with monitoring events and notifying register agents when to apply appropriate behavior based modifications to policy currently running upon the agents.

FIG. 17illustrates the decision making process used by the modelers, according to one aspect of the invention. Referring toFIG. 17at230feedback is received from a device or application being monitored. At232the feedback is processed into a Policy Event Message (PEM) by a monitoring agent. At234the PEM is passed to a policy agent which decides at236whether it is endowed with the necessary policy in order to effect the necessary corrective action based on the PEM. If the agent decides that it has the necessary policy at238a determination is made as to whether the policy has been violated. If the policy has been violated, at240corrective action is performed otherwise, at242the agent does nothing. If it is determined that the agent lacks the necessary policy in order to take action, at244the PEM is passed to a local modeler. At246the local modeler makes a decision as to whether it is able to handle the PEM, by itself or whether it needs further policy. If it is decided that the modeler is able to handle the PEM, at248a determination is made as to whether the policy has been violated. If it is determined that a policy violation has occurred, at250an instruction is sent to the policy agent to perform corrective action. Alternatively, if policy has not been violated, at252the local modeler does nothing. If it is determined that the local modeler lacks the necessary policy to take action, at254the PEM is passed to a regional modeler which makes a decision at256whether it has the necessary policy in order to take action. If it is decided that the regional modeler has the necessary policy to take action then at258a determination is made as to whether the policy has been violated. If the policy has been violated, at260the regional modeler sends instructions which are filtered through the local modelers and is eventually received by an appropriate policy agent whereupon the policy agent takes the necessary corrective action. If it is decided that no policy has been violated, at262the regional modeler does nothing. If a determination is made that further policy is required by the regional modeler at264the PEM is passed to the global modeler. At266the global modeler makes a decision as to whether policy has been violated. If policy has been violated, at268the global modeler sends instructions to a policy agent, which instructions eventually reach a relevant policy agent by passing firstly through the regional modelers and then secondly through one or more local modelers. The instructions are instructions which tell an agent to perform the necessary corrective action.

The local modelers are responsible for picking up change control messages from either a parent modeler or the topology service. The local modelers monitor or listen on a range of well-known ports defined by a system administrator or a client. If the port assignments are defined by a client, the port assignments need to be made at the global level for all the lower level modelers underneath to work correctly.

Characteristics of Local Modeler Behavior

As described the primary function of the local modelers is to deploy, coordinate, and control compound policy statements over multiple managed devices within the system10. Compound policy statements are policies that encompass more than one device/resource distributed within the system10. It coordinates and develops strategies to cope with the various demands the network/application may make.

Each local modelers control state replication of agents which involves replicating the state of each agent or other modelers. This is done in order to make the system10fault-tolerant. Each local modeler goes through a selection process to determine its nearest neighbor that it can safely replicate by doing a ping and checking the return round trip values to and from the various local modelers within its functional domain. The modelers with the lowest round trip values are selected for agent replication.

Each local modeler controls only agents that are registered within its operational ARE or that are being proxied by the local ARE in which the local modeler resides.

Each local modeler coordinates policy between the various policy agents deployed upon an ARE. This includes coordinating policy resource sharing between devices and policy enforcement upon managed devices.

Each local modeler listens for feedback messages sent by devices it has been setup to monitor. It can listen to devices and agents on other ARE's.

Each local modeler also listens for change control (notification) messages sent out by the topology service. These messages are sent by the Topology Service to notify ARE's, and specifically agents when a change in their policy or configuration has occurred. The local Modeler listens to these messages through a well know socket port.

If a policy is a complex policy, the local modeler breaks the policy into a set of simpler policies using a policy calculus and applies them to policy agents or subordinate modelers.

Characteristics of Global Modeler Behavior

The global modeler forms a master scheduler/planner/architect for one or more functional domains. It is responsible for analyzing, in real-time, a single functional domain and determining its optimal usage between various components given various global/regional/local policies applied to the system10. It does this in real-time and manages by sending out commands to the local modelers.

The global modeler has a primary and secondary systems image of the system it is modeling and controlling. The primary systems image represents the current state of a particular functional domain that the global modeler is controlling. The secondary systems image is used for backup purposes and provides a means to test policies on a backup before implementation.

Policy Structure

Policies contain within themselves directives to setup, enforce, and coordinate actions within the network/application they are controlling. Policies know about the participants required to set up a feedback loop and to control and monitor the loop. In effect, policy can be thought of as a coherent set of rules to administer, manage, and control access to network/application resources.

Policies are applied to the topology service. According to one embodiment of the invention, the policy service uses the topology service as a mechanism to link policy and configuration information together for distribution within the system10.

There are two types of policies within the system10viz. simple and compound policies. A simple policy has the following form of an IF Test=True THEN, DO specific ACTION. A simple policy is evaluated in this way; “IF” the condition evaluates to true by testing a variable, “THEN” a specific action (behavior) is applied to a device or application.

A compound policy consists of two or more simple or compound policies grouped together in a statement. A compound policy is evaluated by first evaluating the highest level of containment (the parent compound policy) first, if the outer most condition(s) of the parent compound policy evaluates to true, then the subsequent child policies are evaluated by order of their placement in the compound policy statement array, and by their priority (see below). If the outer most containment compound policy conditions evaluates to false, then no other child evaluations are performed, and the compound policy is evaluated to false.

Policies are prioritized by level of importance. Depending on the priority level associated with a given policy, the policy can have a specific evaluation order.

For example, a policy may be labeled with one of three designations; (1) mandatory, (2) recommended, and (3) don't care. Mandatory policy must always be attempted, recommended policy is attempted if at all possible but are not necessary, and the don't care is self-explanatory.

Policies are linked with configuration information to form a complete policy. A policy that is linked to a specific configuration uses a unique hash key to map from one to the other. The key is used as a reference to link both pieces of information together.

In one embodiment of the invention, policies are chained together to form a policy behavior chain. Multiple policies can be linked together to form behavior chains. A chaining field is defined within a policy, which holds comma delimited policy ID's used to specify which policy should be called next and in what order they are to be executed, for example, PolicyChainField: P12345678, P23456789, P34567890, etc . . .

Policies vary in the level of abstraction from business-level expression of QoS of service level agreements (SLA), to the specification of a set of rules that apply to a specific device/application on the network. Higher-level rules are defined for global and regional modelers. These are called domain level policies, and may have late binding variables that are unspecified, or specified by a classification, whereas the device-level rules used at the local modeler level have no late bindings.

Policy abstraction levels can be represented as services. Services are administrative divisions of functionality.

As described, the global modeler includes a modeler18.4which in one embodiment of the invention defines a policy refinery. The operation of the policy refinery will now be explained with reference toFIG. 18. Referring toFIG. 18at280the refinery monitors/listens to events within system10. At282the refinery detects abnormalities in the system. At284the refinery creates one or more policies to try and fix the abnormality. It bases these policies upon its experience with similar problems. At284the refinery applies these corrective policies and at290the refinery observes the results of the corrective policies. The refinery learns by observing the new behavior of the system10and specifically the effect of the corrective policies on the system. In one embodiment of the invention, the refinery uses numerical methods to determine appropriate modifications to policy. The numerical methods may include the use of Kohonen Self Organizing maps and/or a Dijkstra Self Stabilization Algorithm. A Kohonen Self Organizing map is a neural network algorithm based on unsupervised learning. In another embodiment, the refinery, uses predictive algorithms to predict the failure of a network device and to determine appropriate corrective policy ahead of the failure. At292a determination is made as to whether the problem or abnormality has been remedied. If it is determined that the problem still persists, at288the refinery creates further corrective policy or adjusts previously applied corrective policy and step286is performed again. If the problem has been fixed then at294the refinery updates its knowledge base with information regarding how to fix a similar problem in future.

Services

Services are abstractions of policy or administrative divisions of functionality. Viewed differently, a service is the work performed or offered by a server. As will be appreciated, system10may have various services according to different embodiments of the invention. The message service has already been described. Each of the services has one or more associated servers running the service. What follows is a description of services used in one embodiment of the system10.

Policy Service

The policy service sends policy information to the topology service. The policy service links policy and configuration information together by a hash key generated by the policy service.

An individually managed device can have many policies applied to it at the same time. This refers to the fact that each policy can configure a portion of a devices overall functional capability. Policy can overlap with other policies and the policy service determines when a policy or combinations of policies is invalid.

A new policy is considered invalid if it affects by direct or indirect action other policies already in existence. This can be caused by, for example, two or more policies sharing the same resource; or by implementing a policy that causes an indirect impact by diverting system resources away from existing enforced policies, resulting in over compensation and serious side effects to the system as a whole.

Policies follow a hierarchical distribution chain or tree. This means ARE's that are above it within the tree chain hierarchy can hold policy information which a child node can request.

Policy Deployment Mechanics

Policy Service-to-Topology service: In the policy deployment sequence, policies either new/existing from the policy service are first sent to the to the topology service. The topology service holds a tree that defines a logical management hierarchy for the system10.

Topology Service-to-ARE: Within the topology service, the policies that are active currently reflect the state of the network as controlled and managed by the system10for that particular functional domain. Each ARE after startup/initialization, contacts the topology service to determine which local modeler is assigned to its functional domain. Thereafter the ARE obtains the relevant policies/configurations from the topology service and instantiates appropriate agents to handle the policy or configuration demands. If the ARE is unable to start an agent, it sends a response back to the topology service indicating there was a failure to start the agent on the ARE.

ARE-to-local modeler: When a policy (agent) is instantiated upon an ARE, the ARE registers the policy with the local modeler assigned to its functional domain.

ARE-to-Agent: After connecting to the topology service and determining what policies (agents) are to be started. The ARE goes about instantiating an agent within the ARE as defined by the topology service management tree. Part of instantiating an agent includes notifying the appropriate modeler that a new policy has been applied within the ARE.

Agent (Policy)-to-Device (Direct): The agent (policy) running on the ARE first attempts to issue commands through its device adapter. The first command issued is a status command that shows that the communication channel between the device and the agent's device adapter is working and the device is in a operational state.

Agent-to-Application (Direct): The agent (policy) running on the ARE first attempts to issue a request to the application through its device adapter. The initial request consists of an information status command used to determine if the virtual communications channel is open between the agent (policy) and the application/service through the agent's device adapter.

Agent-to-ARE-to-ARE-to-Agent-to-Device (Proxied): This defines the proxy process that occurs when one agent cannot fulfill a policy agent request on a particular ARE and must seek another ARE to host the request. If the ARE is unable to start the agent, it sends a request back to the topology service requesting another ARE close by to proxy the agent. The topology service sends a request to a neighboring agent to determine if it can host the agent. If the neighboring ARE can, it sends back an acknowledgement to the topology service and the request is then handled on the proxied ARE. Messages sent to the original agent are now all directed to the proxied ARE/Agent. The policy is enforced by the agent and communicated to the actual device through the Device adapter interface.

Agent-to-ARE-to-ARE-to-Agent-to-Application (Proxied): This defines the proxy process that occurs when one agent cannot fulfill a policy agent request on a particular ARE and must seek another ARE to host the request. If the ARE is unable to start the agent, it sends a request back to the topology service requesting another ARE close by to proxy the agent. The topology service sends out a request to a neighboring ARE to determined if it can host the agent. If the proxy ARE can, it sends back an acknowledgment to the topology service and the request is then handled on the proxied ARE. Messages sent to the original agent are now all directed to the proxied ARE/Agent. The policy is enforced by the agent and communicated to the actual application through its Device adapter.

Local modeler-to-Topology service: The local modeler notifies will notify the topology service when an agent running on an ARE is no longer within SLA compliance of an active policy within the system10.

Topology Service-to-Policy Service: The topology service communicates with the Policy Service when a policy being administered by an agent is no longer able to stay within an SLA range. The local modeler signals to the topology service that the agent is no longer able to adequately service the policy (SLA) and that a new policy is needed. The topology service signals the policy service that the policy is no longer adequate and that a new policy is needed. At this point the global modeler would then take over and determine the best course of action needed or the policy service would check to see if any policies are chained to the existing failed policy.

Policy rules have an implicit context in which they are executed. For example, the context of a policy rule could be all packets running on an interface or set of interfaces on which the rule is applied. Similarly, a parent rule provides a context to all of its sub-rules. The context of the sub-rules is the restriction of the context of the parent rule to the set of cases that match the parent rule's condition clause.

The relationship between rules and sub-rules is defined as follows: The parent rule's condition clause is a pre-condition for evaluation of all nested rules. If the parent rule's condition clause evaluates to “false”, all sub-rules are skipped and their condition clauses are not evaluated. If the parent rule's condition evaluates to “true”, the set of sub-rules are executed according to priority. If the parent rule's condition evaluates to “true”, the parent rule's set of actions is executed before execution of the sub-rules actions. A default action is one that is to be executed only if none of the more specific sub-rules are executed. A default action is defined as an action that is part of a catchall sub-rule associated with the parent rule. The association linking the default action(s) in this special sub-rule has the lowest priority relative to all other sub-rule associations.

Topology Service

The topology service ties together both the configuration and policy to a specific device. The topology service acts as a central point within the system that defines the overall system control state and what policies and configurations are defined for each controllable device being managed by the system10.

The topology service notifies ARE's of changes in its structure by sending out a broadcast or multicast message embedded with information about configuration changes. The ARE then alerts an agent that the topology state has changed. The agent then updates itself with new policy to bring itself back into compliance with the topology services system state.

The topology service acts in a passive manner. It does not actively seek out ARE/Agents that are out of synchronization with its network system state. It follows a request/response stateless paradigm similarly used within the HTTP protocol.

Configuration Service

The configuration service stores configurations for each policy used on a managed device within the system10. The configuration service stores information required to carry out a policy on a particular device. This information is device specific making each configuration unique to each device or class of devices.

An individually managed device can have many configurations applied to it at the same time. This is because each policy(s) can configure a portion of a devices overall functional capability. The specific libraries and classes needed for a particular policy-configuration are stored within the configuration service server. Alternatively, the links to the classes and libraries needed are moved. The configuration service stores hardware/software specific commands that can be used to interact with the device/application that is to be controlled by the system10. The configuration service will initialize and make known on a well-known port the configuration for ARE's running within the system10.

Security Service

The system includes a security service to implement security measures. The security service includes an authorization module which defines a checkpoint for incoming requests from sources outside the system10which is used to monitor/defend against un-wanted and un-authorized intrusions into the system10. The authorization module resides on an edge or along the outer perimeter of a network managed by system10. The authorization module assumes that the transmission of data between the sender (Users Browser) and the receiver (authorization module) uses some form of encryption. As described above, in one embodiment the system10uses SSL encryption between the sender and receiver. The authorization module validates user, system and service level requests. The validation and checking of requested actions is performed using an access control list (ACL) along the edge boundary point. The ACL list is used to manage and control the permissions of session related requests within the system10. Only authorized users within the system10have authority to grant ACL rights to system resources. An application request is first identified at the edge of the system10before it is allowed to proceed to its destination inside the system10. The incoming request is scanned for an identifying digital certificate, which is appended or embedded to the incoming request by the sender. The incoming request may, for example, be an HTTP request. The sender is required to attach a digital certificate to the front of each incoming request into the system10using an SSL connection. The authorization module parses and strips the certificates off each incoming request and compares it to an in-memory cache within the authorization module. If there is a match within the cache, the request is validated and passed on to its destination and the session window timer is reset. If there is no match within the cache, a query is then made from the Authorization Module to a data store to determine if the certificate is valid. If the certificate is found in the data store, a session object is created along with the ACL list. A session window timeout timer is then started and the request is allowed into system10. If the certificate cannot be validated or found within the datastore or there is no certificate to the request, the request is considered invalid and ignored. If a significant number of requests that are deemed invalid are from the same IP address, an administrator can set a filter so that IP addresses from bad requesters are added to a bad IP address list and so that these IP addresses can be ignored by the system10in future. Users are identified from outside the system10using a certificate generated at the site using the system10. Usually the site is that of a company which then assumes responsibility to the certificate to outside customers. The certificate authentication server is usually a third party application which is used to authenticate the certificate used by the incoming request.

Session Service

The system10defines a session as a request window from a source outside the system10that has a specific time window in which actions can be performed and service level requests handled. A session holds information regarding the requesting clients permissions within the system10. This information consists of Access Control Lists (ACL) relating to devices (servers) and applications the requesting client has permission to use. A session also holds references to workflows used within a session time window. These workflows are temporary holding storage places for intermediate data generated by a transaction between a client session and a backend service within system10. A session service starts a session by starting when a user logs into system10and issues a command. The expiration time defines a time window within which user actions are accepted. Actions outside this window are considered invalid. A valid time window is defined for a specific interval of time, which the a system administrator defines. The time window interval is reset and a new expiration count down clock is started for the user session window when the user sends another request within the existing user session time interval. A session is non-localized in the sense that any point within the system10can be used as an entry point for a session. The session information is distributed between the topology services so as to provide a global access point for session requests.

Workflow Service

The system10uses a workflow service which is a transaction-processing (TP) monitor that provides a temporary storage facility for intermediate transaction data. The workflow service is used to provide optimal bandwidth and resource usage between different TP components within the system10. It acts as a fault-tolerant temporary storage area for data being processed over the web. The workflow service defines workflow object comprising of a data cache that holds intermediate data being processed for a transaction monitored by the system10.

Time Service

The system10uses a time service to time stamp and synchronize messages and events within the system10. The time service provides a basic utility library of API's to help in coordination of system events. Support for single, periodic, and custom time events are provided. The Time Service is responsible for synchronizing the various components using point-to-point messages and broadcast events within the system.

Specific Implementation

FIG. 19shows an implementation300of a system10in accordance with the invention, using CORBA. The implementation300includes a managed device302which is managed or controlled by an ARE304. The ARE304includes a security manager304.1and a class loader304.2. A monitoring agent306monitors for feedback from device302. A policy agent308issues commands and communicates with the device302via a device adapter310. The ARE304obtains configuration information at runtime from a configuration service312during an auto discovery phase in which the ARE304is updated with system configuration information. A CORBA session is established between the ARE304and a CORBA naming service

In particular the system10defines a session as a request window from a source outside the system10control domain that has a specific time window in which actions can be performed and service level requests handled.

The session holds information regarding the requesting clients permissions within the system10. This information comprises Access Control Lists (ACL) relating to devices (Servers) and applications the requesting client has permission to use.

A session object is created to hold references to objects that are used within a session time window. These objects are temporary holding storage places for intermediate data generated by a transaction between the client session and some backend service within domains. An expiration timer is started when an agent activates and issues a command. Agent interactions are only accepted within this valid time window. A valid time window is defined for a specific interval of time, which a system administrator defines. The time window interval is reset and a new expiration count down clock is started for the user session window when the user sends another request within the existing user session time interval. A session is non-localized in the sense that any agent within the domain can be approached as an entry point for a session. The session information will be distributed between all the Topology Services running so as to provide a global access point for session requests. The naming service314saves information to a persistent data store316which is backed up into a back-up persistent data store318. The implementation300includes a policy configuration data storage320which is accessed by a policy service and a policy configuration service324. Each of the policy service322and policy configuration service324communicate and exchange information with a topology service326. The topology service326is able to broadcast sockets based broadcasts/alerts to the ARE304. To alert the ARE304of changes in network policy. Topology information stored in the topology server326is replicated in a data store328.

FIG. 20shows another implementation350of a system10in accordance with the invention. The implementation350is similar to the implementation300and accordingly the same reference numerals have been used to describe the same or similar features. The main difference between implementation between350and implementations300is that implementation350utilizes an LDAP server352which is accessed by class loader304.2. The LDAP server352is replicated in LDAP server354and in one or more federated LDAP servers358.

In implementations300and350other services necessary for the operation of system10, which services have already been described, have not been included for the sake of clarity. However, a reader skilled in the art will appreciate how these services relate to implementations300and350.

In the above description reference was made to servers at various places. For example, each of the services was described as running on one or more servers.FIG. 21shows various components making up a server300in accordance with one embodiment of the invention. Referring toFIG. 21it will be seen that system hardware300includes a memory304, which may represent one or more physical memory devices, which may include any type of random access memory (RAM) read only memory (ROM) (which may be programmable), flash memory, non-volatile mass storage device, or a combination of such memory devices. The memory302is connected via a system bus310to a processor302. The memory304includes instructions306which when executed by the processor302cause the processor to perform the methodology of the invention or run one or more services as discussed above. Additionally, the system300includes a disk drive306and a CD ROM drive308each of which is coupled to a peripheral-device and user-interface312via bus310. Processor302, memory304, disk drive306and CD ROM308are generally known in the art. Peripheral-device and user-interface312provide an interface between system bus310and various components connected to a peripheral bus316as well as to user interface components, such as display, mouse and other user interface devices. A network interface314is coupled to peripheral bus316and provides network connectivity to system300.

For the purposes of this specification, a machine-readable medium includes any mechanism that provides (i.e. stores) information in a form readable by a machine (e.g. computer) for example, a machine-readable medium includes read-only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; flash memory devices; etc.

It will be apparent from this description the aspects of the present invention may be embodied, at least partly, in software. In other embodiments, hardware circuitry may be used in combination with software instructions to implement the present invention. Thus, the techniques are not limited to any specific combination of hardware circuitry and software.

Although the present invention has been described with reference to specific exemplary embodiments, it will be evident that various modification and changes can be made to these embodiments without departing from the broader spirit of the invention as set forth in the claims. Accordingly, the specification and drawings are to be regarded in an illustrative sense rather than in a restrictive sense.

Further, particular methods of the invention have been described in terms of computer software with reference to a series of flowcharts. The methods to be performed by a computer constitute computer programs made up of computer-executable instructions illustrated as blocks (acts). Describing the methods by reference to a flowchart enables one skilled in the art to develop such programs including such instructions to carry out the methods on suitably configured computers (the processing unit of the computer executing the instructions from computer-readable media). The computer-executable instructions may be written in a computer programming language or may be embodied in firmware logic. If written in a programming language conforming to a recognized standard, such instructions can be executed on a variety of hardware platforms and for interface to a variety of operating systems. In addition, the present invention is not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the invention as described herein. Furthermore, it is common in the art to speak of software, in one form or another (e.g. program, procedure, process, application, module, logic . . . ), as taking an action or causing a result. Such expressions are merely a shorthand way of saying that execution of the software by a computer causes the processor of the computer to perform an action or a produce a result. It will be appreciated that more or fewer processes may be incorporated into the methods as described above without departing from the scope of the invention, and that no particular order is implied by the arrangement of blocks shown and described herein.

EXAMPLES

Specific examples of system10components described above are now provided.

(a) In a JAVA embodiment, the messaging adapter112may be described by the following class definitions:

super actor/* sending messages is an action */methodsSend +<Rcp> [+<Ref>] +<Msg-type> +<Content> {...}class ReceiveQueuesuper sensor/* receiving messages is a sensing activity */methodsrec_s ?<Sdr> ?<Msg-type> ?<Content> {...}rec_a ?<Sdr> ?<Msg-type> ?<Content> [+<Timeout>] {...}
These definitions provide two functions which allow an agent110to receive messages from other agents viz. rec_s and rec_a. rec_s is a function that waits synchronously until a message has been received. The arguments denote (from left to right) the sender of the message, message type, and actual message content. If the arguments are provided with values, only messages matching the parameter descriptions are returned. rec_a looks for messages asynchronously and fails if no matching messages have been received. rec_a has an optional time-out parameter allowing it to specify a time interval during which the message queue is monitored for matching messages. The default value for this time interval may be set to zero.

(b) Each message may be represented as a tuple:Msg=(Id, Sender, Recipient, Reference, Type, Content), in which

Reference=reference to a message Id (this is an optional field and used if a hierarchical message layout is desired;

Type=the taxonomic identifier of this message andContent=the actual message itself

(c) The following schema declaration may be used to implement a PKB policy repository:

(d) The assertional, retrieval and active information services described above are defined below:

PKB Assertional ServicescreateKBObj(Id)returns a unique identification of a newly createdKB object.createPolicyObj(Id,creates an instance of a concept denoted byPolicy)concept and binds it to the object identified by IdcreateRelation(IdList,defines an instance of a new relation denoted byRelation)Relation Rel among the concept instances denotedby the object identifiers in IdList. The ordering ofthe members of IdList determines their orderingin the relation.setValue(Id, Attribute,assigns the value denoted by newValue to thenewValue)attribute of the concept instance denoted by Id.deleteKBObj(Id)delete an object; deleting an object that is boundto a concept instance deletes the concept instanceand all instances of relations having this conceptinstance as a member.DeletePolicyDeleted the instance of a Policy denoted by IdListdeleteRelation(IdList,Deletes the instance of a Relation denoted byRelation)IdListremoveValue(Id,removes the value for the attribute of the conceptAttribute)instance denoted by Id.

PKB retrieval ServicesreturnPolicy(PolicyList,Returns a list of all instances of PolicyIdList)returnPolicyBool(Id,Returns true if the policy denoted by Id is aPolicy, bool)member of the Policy Knowledge BasereturnRelMembersReturns a list of policy instances denoting all(relation, ListofId)tuples that define the relation desiredreturnMemberBoolReturns true if the tuple denoted by IdList is a(IdLiSt, Relation, IdList)member of the RelationdeleteKBObj(Id)delete an object; deleting an object that isbound to a concept instance deletes theconcept instance and all instances of relationshaving this concept instance as a member.

PKB Information/versioning servicesversionPolicy(Policy, Source,Causes any modification of policyDestination, Id)instances to be sent to the destinationaddress specified - if requestedversionRelation(Relation, Source,Causes any modification of relationDestination, Id)instances to be sent to the destinationaddress specified - if requested

(e) The control unit118may use a PolicyMethodActor Class such as the one shown below

(f) In the example below, “class Layer” defines the fundamental activity cycle of the control unit118:

(g) The Domain Server class defined below may be used to implement the domain adapter115described with reference toFIG. 7.

(h) The perception buffer may be defined by a Perception Buffer Class defined below:

(i) Services are represented in Interface Description Language, i.e. ORB (IDL) as follows:

A policy can be represented in IDL as follows: