Abstract:
A system and method to manage networked resources from a central management node. The management node is exposed to a common web services interface for a plurality of managed nodes having different system stacks. The management node and the managed nodes employ a schema to encode arbitrary data corresponding to management requests and responses into web services messages.

Description:
BACKGROUND 
     1. Field 
     Embodiments of the invention relate to management of resources in a computer system. More specifically, embodiments of the invention relate to providing the unified interface for management communications independent of the underlying system stack on the managed nodes. 
     2. Background 
     Historically, each platform has its own management interface. For example, the management interface for advanced business application programming (ABAP) platforms differs from the management interface for Java platforms, such as the Java 2 Enterprise Edition (J2EE) engine, which in turn also differs from a management interface for platforms created in native C. At a minimum, these different interfaces require the management node to maintain different protocols for management of each managed node. Moreover, the management node is required to know which underlying system stack it is attempting to manage when sending out management requests. Accordingly, the platform dependent nature of the management interface make centralize management of different nodes based on different systems stacks cumbersome or impossible. 
     SUMMARY OF THE INVENTION 
     A system and method to manage networked resources from a central management node is described. The management node is exposed to a common web services interface for a plurality of managed nodes having different system stacks. The management node and the managed nodes employ a schema to encode arbitrary data corresponding to management requests and responses into web services messages. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
       The invention is illustrated by way of example and not by way of limitation in the figures of the accompanying drawings in which like references indicate similar elements. It should be noted that references to “an” or “one” embodiment in this disclosure are not necessarily to the same embodiment, and such references mean at least one. 
         FIG. 1  is a block diagram of the system of one embodiment of the invention. 
         FIG. 2  is an example sequence diagram for a request response transaction in one embodiment of the invention. 
         FIG. 3  is a flow diagram of operation of one embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1  is a block diagram of the system of one embodiment of the invention. The system provides the unified interface for management of different platforms. The interface is independent of the underlying system software stack. The management node  100  sends management requests to manage nodes  102 ,  104 ,  106 . Communication between the management node  100  and the managed nodes  102 ,  104 ,  106  is through a web services interface. In a depicted embodiment, manage node  102  has an advanced business programming applications (ABAP) system stack and is referred to as an AMX agent. Managed node  104  has a Java system stack and is referred to as a JMX agent. Managed node  106  has a C system stack and is referred to as a C Agent. Management node  100  includes a Java management extensions (JMX) connection  110  to create management requests satisfying the JMX specification promulgated by Sun Microsystems of Mountain View, Calif. The JMX connection uses Query Service MBean to query local MBeans to provide Application Server Port Number, where the web service is published, and authentication details. Using these details the management node  100  uses its web services client proxy  112  to connect to remote MBean servers on the managed nodes  102 ,  104 ,  106 . 
     JMX connection  110  uses a schema  108  to encode management requests as an extensible markup language (XML) string. In one embodiment, the schema  108  includes two XML schema document (XSD) files. The first such file defines the XML data format for metadata or type definitions. The second file defines the XML data format for values. 
     The data value XML format is used to transport arbitrary data structures such as the attribute values, method parameter values and method return value of the Mbeans and is defined as a complex type in the schema: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;xs:element name=“value” type=“nwa-data:value”/&gt;, 
               
               
                   
                 &lt;xs:complexType name=“value”&gt; 
               
               
                   
                   &lt;xs:choice&gt; 
               
               
                   
                     &lt;xs:group ref=“nwa-data:simpleValue”/&gt; 
               
               
                   
                     &lt;xs:group ref=“nwa-data:compositeValue”/&gt; 
               
               
                   
                     &lt;xs:group ref=“nwa-data:arrayValue”/&gt; 
               
               
                   
                     &lt;xs:element ref=“nwa-data:propertiesValue”/&gt; 
               
               
                   
                   &lt;/xs:choice&gt; 
               
               
                   
                 &lt;/xs:complexType&gt; 
               
               
                   
                   
               
             
          
         
       
     
     From the definition the data value is a choice between the group of simple/composite/array value. 
     The “simple” value group (simple field in AMX) is defined in the schema as sequence of simple type and simple value: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;!- simple group (corresponds to ABAP elementary data type) --&gt; 
               
               
                   
                 &lt;xs:group name=“simpleValue”&gt; 
               
               
                   
                 &lt;xs:sequence&gt; 
               
               
                   
                  &lt;xs:element ref=“nwa-type:simpleType” minOccurs=“0”/&gt; 
               
               
                   
                  &lt;xs:choice&gt; 
               
               
                   
                   &lt;xs:element name=“character” type=“xs:unsignedShort”/&gt; 
               
               
                   
                   &lt;xs:element name=“string” type=“xs:string”/&gt; 
               
               
                   
                   &lt;xs:element name=“boolean” type=“xs:boolean”/&gt; 
               
               
                   
                   &lt;xs:element name=“decimal” type=“xs:decimal”/&gt; 
               
               
                   
                   &lt;xs:element name=“float” type=“xs:float”/&gt; 
               
               
                   
                   &lt;xs:element name=“double” type=“xs:double”/&gt; 
               
               
                   
                   &lt;xs:element name=“date” type=“xs:dateTime”/&gt; 
               
               
                   
                   &lt;xs:element name=“long” type=“xs:long”/&gt; 
               
               
                   
                   &lt;xs:element name=“int” type=“xs:int”/&gt; 
               
               
                   
                   &lt;xs:element name=“integer” type=“xs:integer”/&gt; 
               
               
                   
                   &lt;xs:element name=“short” type=“xs:short”/&gt; 
               
               
                   
                   &lt;xs:element name=“byte” type=“xs:byte”/&gt; 
               
               
                   
                   &lt;xs:element name=“duration” type=“xs:duration”/&gt; 
               
               
                   
                   &lt;xs:element name=“hexBinary” type=“xs:hexBinary”/&gt; 
               
               
                   
                   &lt;xs:element name=“unsignedByte” type=“xs:unsignedByte”/&gt; 
               
               
                   
                   &lt;xs:element name=“base64Binary” type=“xs:base64Binary”/&gt; 
               
               
                   
                  &lt;/xs:choice&gt; 
               
               
                   
                 &lt;/xs:sequence&gt; 
               
               
                   
                 &lt;/xs:group&gt; 
               
               
                   
                 &lt;!- simple type--&gt; 
               
               
                   
                 &lt;xs:element name=“simpleType” type=“simpleType”/&gt; 
               
               
                   
                 &lt;xs:simpleType name=“simpleType”&gt; 
               
               
                   
                  &lt;xs:restriction base=“xs:string”&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:string”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:boolean”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:decimal”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:float”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:double”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:dateTime”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:long”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:int”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:integer”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:short”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:byte”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:duration”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:base64Binary”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:unsignedShort”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:hexBinary”/&gt; 
               
               
                   
                   &lt;xs:enumeration value=“xs:unsignedByte”/&gt; 
               
               
                   
                  &lt;/xs:restriction&gt; 
               
               
                   
                 &lt;/xs:simpleType&gt; 
               
               
                   
                   
               
             
          
         
       
     
     XML example of simple string value which would be valid against the schema: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;?xml version=“1.0” encoding=“UTF-8”?&gt; 
               
               
                   
                 &lt;nwa-data:value&gt; 
               
               
                   
                  &lt;nwa-type:simpleType&gt;xs:string&lt;/nwa-type:simpleType&gt; 
               
               
                   
                  &lt;nwa-data:string&gt;Hello, world!&lt;/nwa-data:string&gt; 
               
               
                   
                 &lt;/nwa-data:value&gt; 
               
               
                   
                   
               
             
          
         
       
     
     Due to the optional (minOccurs=“0”) simpleType element, the following example would be also valid against the schema: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;?xml version=“1.0” encoding=“UTF-8”?&gt; 
               
               
                   
                 &lt;nwa-data:value&gt; 
               
               
                   
                   &lt;nwa-data:string&gt;Hello, world!&lt;/nwa-data:string&gt; 
               
               
                   
                 &lt;/nwa-data:value&gt; 
               
               
                   
                   
               
             
          
         
       
     
     The composite value group (structure in AMX) is defined in the schema as a sequence of two complex elements: 
     
       
         
               
             
           
               
                   
               
             
             
               
                 &lt;!-- composite group (corresponds to ABAP structure)--&gt; 
               
               
                 &lt;xs:group name=“compositeValue”&gt; 
               
               
                  &lt;xs:sequence&gt; 
               
               
                   &lt;xs:element ref=“nwa-type:compositeType” minOccurs=“0”/&gt; 
               
               
                   &lt;xs:element ref=“nwa-data:composite”/&gt; 
               
               
                  &lt;/xs:sequence&gt; 
               
               
                 &lt;/xs:group&gt; 
               
               
                 &lt;!-- composite type (nwa_protocol_type.xsd)--&gt; 
               
               
                 &lt;xs:element name=“compositeType” type=“compositeType”/&gt; 
               
               
                 &lt;xs:complexType name=“compositeType”&gt; 
               
               
                  &lt;xs:complexContent&gt; 
               
               
                  &lt;xs:extension base=“baseType”&gt; 
               
               
                  &lt;xs:sequence&gt; 
               
               
                   &lt;xs:element name=“compositeItem” type=“itemType” 
               
               
                 maxOccurs=“unbounded”/&gt; 
               
               
                  &lt;/xs:sequence&gt; 
               
               
                  &lt;xs:attribute name=“typeID” type=“xs:string” use=“optional”/&gt; 
               
               
                  &lt;/xs:extension&gt; 
               
               
                  &lt;/xs:complexContent&gt; 
               
               
                 &lt;/xs:complexType&gt; 
               
               
                 &lt;!-- composite value (nwa_protocol_data.xsd) --&gt; 
               
               
                 &lt;xs:element name=“composite” type=“composite”/&gt; 
               
               
                 &lt;xs:complexType name=“composite”&gt; 
               
               
                  &lt;xs:sequence&gt; 
               
               
                  &lt;!-- elements order and type must follow the corresponding type --&gt; 
               
               
                  &lt;xs:element name=“compositeItem” type=“item” 
               
               
                 maxOccurs=“unbounded”/&gt; 
               
               
                  &lt;/xs:sequence&gt; 
               
               
                 &lt;/xs:complexType&gt; 
               
               
                   
               
             
          
         
       
     
     The following is an example of a composite data value valid against the schema: 
     
       
         
               
             
           
               
                   
               
             
             
               
                 &lt;?xml version=“1.0” encoding=“utf-8”?&gt; 
               
               
                 &lt;nwa-data:value typeName=“SAP_ITSAM_Structure”&gt; 
               
               
                 &lt;!-- type description (nwa_protocol_type.xsd)--&gt; 
               
               
                  &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                  &lt;nwa-type:compositeItem typeName=“C1”&gt; 
               
               
                   &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                   &lt;nwa-type:simpleType&gt;xs:string&lt;/nwa-type:simpleType&gt; 
               
               
                  &lt;/nwa-type:compositeItem&gt; 
               
               
                  &lt;nwa-type:compositeItem typeName=“C2”&gt; 
               
               
                   &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                   &lt;nwa-type:simpleType&gt;xs:boolean&lt;/nwa-type:simpleType&gt; 
               
               
                  &lt;/nwa-type:compositeItem&gt; 
               
               
                  &lt;nwa-type:compositeItem typeName=“C3”&gt; 
               
               
                   &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                   &lt;nwa-type:compositeType 
               
               
                 typeName=“SAP_ITSAM_InnerStructure”&gt; 
               
               
                    &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                    &lt;nwa-type:compositeItem typeName=“C1”&gt; 
               
               
                     &lt;nwa-type:description&gt;n/a&lt;/nwa- 
               
               
                 type:description&gt; 
               
               
                     &lt;nwa-type:simpleType&gt;xs:string&lt;/nwa- 
               
               
                 type:simpleType&gt; 
               
               
                    &lt;/nwa-type:compositeItem&gt; 
               
               
                    &lt;nwa-type:compositeItem typeName=“C2”&gt; 
               
               
                     &lt;nwa-type:description&gt;n/a&lt;/nwa- 
               
               
                 type:description&gt; 
               
               
                     &lt;nwa-type:simpleType&gt;xs:short&lt;/nwa- 
               
               
                 type:simpleType&gt; 
               
               
                    &lt;/nwa-type:compositeItem&gt; 
               
               
                    &lt;nwa-type:compositeItem typeName=“C3”&gt; 
               
               
                     &lt;nwa-type:description&gt;n/a&lt;/nwa- 
               
               
                 type:description&gt; 
               
               
                     &lt;nwa-type:simpleType&gt;xs:string&lt;/nwa- 
               
               
                 type:simpleType&gt; 
               
               
                    &lt;/nwa-type:compositeItem&gt; 
               
               
                    &lt;nwa-type:compositeItem typeName=“TimeStamp”&gt; 
               
               
                     &lt;nwa-type:description&gt;n/a&lt;/nwa- 
               
               
                 type:description&gt; 
               
               
                     &lt;nwa-type:simpleType&gt;xs:dateTime&lt;/nwa- 
               
               
                 type:simpleType&gt; 
               
               
                    &lt;/nwa-type:compositeItem&gt; 
               
               
                   &lt;/nwa-type:compositeType&gt; 
               
               
                  &lt;/nwa-type:compositeItem&gt; 
               
               
                  &lt;nwa-type:compositeItem typeName=“TimestamP”&gt; 
               
               
                   &lt;nwa-type:description&gt;n/a&lt;/nwa-type:description&gt; 
               
               
                   &lt;nwa-type:simpleType&gt;xs:dateTime&lt;/nwa-type:simpleType&gt; 
               
               
                  &lt;/nwa-type:compositeItem&gt; 
               
               
                 &lt;/nwa-type:compositeType&gt; 
               
               
                 &lt;!-- value (nwa_protocol_data.xsd)--&gt; 
               
               
                 &lt;nwa-data:composite&gt; 
               
               
                  &lt;nwa-data:compositeItem name=“C1”&gt; 
               
               
                   &lt;nwa-data:string&gt;Hello, world!&lt;/nwa-data:string&gt; 
               
               
                  &lt;/nwa-data:compositeItem&gt; 
               
               
                  &lt;nwa-data:compositeItem name=“C2”&gt; 
               
               
                   &lt;nwa-data:boolean&gt;false&lt;/nwa-data:boolean&gt; 
               
               
                  &lt;/nwa-data:compositeItem&gt; 
               
               
                  &lt;nwa-data:compositeItem name=“C3”&gt; 
               
               
                   &lt;!- in case the inner structure is initial it will be represented as 
               
               
                 a NULL value --&gt; 
               
               
                   &lt;nwa-data:unsignedByte&gt;32&lt;/nwa-data:unsignedByte&gt; 
               
               
                  &lt;/nwa-data:compositeItem&gt; 
               
               
                  &lt;nwa-data:compositeItem name=“TimestamP”&gt; 
               
               
                   &lt;nwa-data:date&gt;2007-01-18T09:16:33.317386Z&lt;/nwa-data:date&gt; 
               
               
                  &lt;/nwa-data:compositeItem&gt; 
               
               
                 &lt;/nwa-data:composite&gt; 
               
               
                 &lt;/nwa-data:value&gt; 
               
               
                   
               
             
          
         
       
     
     The array value group (table in AMX) defined in the schema as a sequence of the following complex elements: 
     
       
         
               
             
           
               
                   
               
             
             
               
                 &lt;!-- array value group --&gt; 
               
               
                 &lt;xs:group name=“arrayValue”&gt; 
               
               
                  &lt;xs:sequence&gt; 
               
               
                   &lt;xs:element ref=“nwa-type:arrayType” minOccurs=“0”/&gt; 
               
               
                   &lt;xs:element ref=“nwa-data:array” minOccurs=“0”/&gt; 
               
               
                   &lt;xs:element ref=“nwa-data:primitiveArray” minOccurs=“0”/&gt; 
               
               
                  &lt;/xs:sequence&gt; 
               
               
                 &lt;/xs:group&gt; 
               
               
                 &lt;!-- array type --&gt; 
               
               
                 &lt;xs:element name=“arrayType” type=“arrayType”/&gt; 
               
               
                 &lt;xs:complexType name=“arrayType”&gt; 
               
               
                  &lt;xs:complexContent&gt; 
               
               
                   &lt;xs:extension base=“baseType”&gt; 
               
               
                    &lt;xs:sequence&gt; 
               
               
                     &lt;xs:element      name=“arrayElement” 
               
               
                 type=“itemType”/&gt; 
               
               
                     &lt;xs:element name=“dimension” type=“xs:int”/&gt; 
               
               
                    &lt;/xs:sequence&gt; 
               
               
                   &lt;/xs:extension&gt; 
               
               
                  &lt;/xs:complexContent&gt; 
               
               
                 &lt;/xs:complexType&gt; 
               
               
                 &lt;!-- array value --&gt; 
               
               
                 &lt;xs:element name=“array” type=“array”/&gt; 
               
               
                 &lt;xs:complexType name=“array”&gt; 
               
               
                  &lt;xs:sequence&gt; 
               
               
                  &lt;xs:element name=“arrayElement” type=“item” minOccurs=“0” 
               
               
                 maxOccurs=“unbounded”/&gt; 
               
               
                  &lt;/xs:sequence&gt; 
               
               
                  &lt;xs:attribute name=“className” type=“xs:string” use=“optional”/&gt; 
               
               
                 &lt;/xs:complexType&gt; 
               
               
                   
               
             
          
         
       
     
     The composite/array type contains a sequence of one or more compositeItems/arrayElements which could be of different types like simple/composite/array type: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;!-- item type (corresponds to ABAP structure component or line of 
               
               
                   
                 table) --&gt; 
               
               
                   
                 &lt;xs:complexType name=“itemType”&gt; 
               
               
                   
                  &lt;xs:complexContent&gt; 
               
               
                   
                   &lt;xs:extension base=“baseType”&gt; 
               
               
                   
                    &lt;xs:sequence&gt; 
               
               
                   
                     &lt;xs:choice&gt; 
               
               
                   
                      &lt;xs:element ref=“simpleType”/&gt; 
               
               
                   
                      &lt;xs:element ref=“compositeType”/&gt; 
               
               
                   
                      &lt;xs:element ref=“arrayType”/&gt; 
               
               
                   
                     &lt;/xs:choice&gt; 
               
               
                   
                    &lt;/xs:sequence&gt; 
               
               
                   
                   &lt;/xs:extension&gt; 
               
               
                   
                  &lt;/xs:complexContent&gt; 
               
               
                   
                 &lt;/xs:complexType&gt; 
               
               
                   
                   
               
             
          
         
       
     
     The composite/array value contains a sequence of one or more compositeItems/arrayElements which could be of different types like simple/composite/array value: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 &lt;!-- Item is always inside composite element and wraps simple 
               
               
                   
                 (mixed=true), or array element --&gt; 
               
               
                   
                 &lt;xs:complexType name=“item”&gt; 
               
               
                   
                  &lt;xs:choice&gt; 
               
               
                   
                   &lt;xs:element ref=“nwa-data:composite”/&gt; 
               
               
                   
                   &lt;xs:element ref=“nwa-data:array”/&gt; 
               
               
                   
                   &lt;xs:element ref=“nwa-data:primitiveArray”/&gt; 
               
               
                   
                   &lt;xs:element ref=“nwa-data:propertiesValue”/&gt; 
               
               
                   
                   &lt;xs:group ref=“nwa-data:simpleValue”/&gt; 
               
               
                   
                  &lt;/xs:choice&gt; 
               
               
                   
                  &lt;xs:attribute name=“name”/&gt; 
               
               
                   
                 &lt;/xs:complexType&gt; 
               
               
                   
                   
               
             
          
         
       
     
     The management node  100  includes the web services client proxy  112  to which each of the managed nodes  102 ,  104 ,  106  expose a common web services interface. JMX connection  110  provides the XML string to the web services client proxy  112 , the web services client proxy  112  creates a web services message containing the XML string. In one embodiment, web services client proxy  112  creates simple object access protocol (SOAP) message having the XML string as its payload. The web services message, including the request, is placed on the transport layer and claimed by web services server proxy in the target managed node  102 ,  104 , or  106 . 
     In the case of a management request to JMX agent  104 , web services server proxy  150  claims the message off of the transport layer removes the header and other web services information and passes the XML string to JMX management bean (MBean) server  152 , JMX MBean server  152  deserializes the XML string to recover the request object formulates a response to the request object consistent with schema  108  and passes the XML string to the web services server proxy to be returned as part of the payload of our response web services message. 
     For requests directed to manage node  106 , web services server proxy  160  claims the message off of the transport layer and passes the XML string to host control  162 . Host control  162  interprets the string consistent with schema  108  and prepares a response XML string satisfying the schema  108  which is then returned to management node  100  in the payload of a web services response message. 
     The request having managed node  102  as their target are claimed by web services server proxy  120  from the transport layer. Within the ABAP management extension (AMX) agent  102 , the AMX MBean server offers an interface that allows registration and deregistration of MBeans, getting and setting MBean attribute values, and method invocation of the MBeans. However, in ABAP process contexts are strictly bound to the actual user and are only available as long as the work processes is running on that context. As a result, neither the AMX MBean server  124  nor any of the AMX MBeans live somewhere in ABAP, but rather are created each time a request has to be processed. 
     This requires that the server and the MBeans are instantiated, on request. Therefore, the AMX MBeans server  124  instantiates the MBeans in its context to be able to access them when a request is received. Since the MBeans are not persistent beyond a request/response transaction, the necessary for the MBean to persistently store its status if it is desirable to continue in the previous state when reinstantiated on a subsequent request. 
     Significantly, these facets of ABAP also make it possible that two parallel requests directed to managed node  102  would result in the creation of two different contexts and two different MBean servers. Accordingly, an AMX request broker  122  is provide to insure that if multiple AMX MBean servers exist within agent  102 , the request coming in through web services server proxy  120  is directed to the correct MBean server. The AMX request broker  122  relieves the burden on the management node  100  of knowing to which MBean server on the managed node  102  the request should be directed. In one embodiment, AMX request broker  122  uses a remote function call to get the MBean server location. 
     Once the location is known, web services server proxy  120  passes the XML string from the payload of the web services message to AMX MBean server  124 . The AMX XML parser  126  uses schema  108  to recover the request object. In one embodiment, AMX MBean server  124  exposes five functions to be remotely accessed: i) “get,” which allows a request to get the value of a specific attribute of a named MBean; ii) “put,” which allows a request to set the value of a specific attribute of a named MBean; iii) “invoke,” which allows the request to invoke an operation on an MBean; iv) “get attributes,” which allows a request to get the values of several attributes of a named MBean; and v) “set attributes,” which allows a request to set the value of several attributes of a named MBean. In all cases, the MBean is identified by its object name. 
     As noted previously AMX MBean server allows for registration and deregistration of MBeans. To that end, local functions “register MBean,” registers a managed resource as an MBean in the AMX registry  130  and “unregister MBean,” unregisters a managed resource from the AMX registry  130 . Finally, local function “query names” is provided, which gets the names of MBean controlled by type AMX registry  130 . This method allows names of all MBeans to be obtained or the names of a set of MBeans specified by the pattern matching to be obtained. The set of object names for the MBeans selected are returned. 
     AMX invocation handler  128  creates the MBeans necessary to handle the request. A set of MBeans include AMX query service  132 , AMX event service  136 , AMX MBeanInfo service  138  and AMX managed resource MBeans  134 - 1 ,  134 - 2 ,  134 -N (generically  134 ). The managed resource MBeans  134  each model a managed resource based on resource data  140 , which provides the data corresponding to each physical resource that is managed. 
     The AMX query service itself is implemented as an MBean. It is used to resolve local queries for MBean object names. The method QUERYNAMESWITHMULTIPLEPATTERNS accepts object name patterns as input. It returns all object names matching to these patterns. Furthermore the MBean supports mass operations as INVOKEFORNAMES (invokes a method for many MBeans) and GETATTRVALUESFORNAMES (returns attribute values for many MBeans). The AMX event service MBean allows the registration of events. If such an event is raised, the management node receives a notification. The AMX MbeanInfo service provides the meta data (method signature) about MBeans. 
     AMX MBean server  124  constructs the response to an outstanding request as an XML string valid under schema  108  and passed it back to the web services server proxy  120 . The web services server proxy  120  constructs a web services message response having the XML string in its payload. That message is then returned to management node  100 . Management node  100  may then recover the XML string and deserialize it consistent with the schema  108 . 
       FIG. 2  is an example sequence diagram for an AMX request response transaction in one embodiment of the invention. This example is the function INVOKE. This method is used to query local AMX MBeans and invoke an operation of an MBean by passing the corresponding object name, the operation name and the operation parameter values (which are arbitrary data structures) passed within the base64 encoded XML strings through the web service interface according to the schema  108 . 
     A SOAP request is sent from web services client  112  to WS Server proxy  120 . AMX Request Broker  122  performs a remote function call to obtain the MBean location for the object name specified in the SOAP request and returns the destination at  206  to the web services proxy  120 . Web services proxy uses the destination returned from the remote function call to call the function module SAMX_INVOKE  230  to create the MBean server  124  at  212 . The AMX server  124  creates the AMX MBean  134  at  208 . At  220 , AMX XML parser  126  parses the incoming XML string that was encoded consistent with the schema and deserialized the string to acquire ABAP parameters to execute on the AMX MBean  134  at  222 . The executed method returns an ABAP value at  224 . The returned ABAP value is serialized and returned as a XML string valid under the schema at  228 . The AMX MBean server then returns the return to SAMX_INVOKE  230  at  219 . SAMX_INVOKE function  230  returns the XML value at  216  to the web services server proxy  120 . The return values (e.g., the XML string) are included in a payload of a SOAP response  218  back to web services client  112 . 
       FIG. 3  is a flow diagram of operation of one embodiment of the invention. At block  302 , a management node sends the web services message to a managed node having a management request contained in the payload of the web services message. At block  304 , the managed node extracts the management request from the web services message. At block  306 , a determination is made if an MBean server exists. For example, a Java based managed node would not need to recreate an MBean server each time as an MBean server would be resident. However, an ABAP managed node would not have an existing MBean server thereon. If no MBean server exists, the MBean server are instantiated at block  308 . Subsequently, the MBeans to be used at the MBean server is instantiated at block  310 . Once the MBean server exists or is instantiated, the XML payload is parsed at block  312 . At block  314 , a response object is created based on the request received. At block  313 , the system involves a method to obtain the information needed for a response. The response object is serialized into an XML string according to a schema at block  316 . The serialized XML string is added to the payload of a web services response message at block  318  by web services server proxy in the managed node. That response is put on the transport layer directed to the management node at block  320 . The management node then extracts a response from the web services message and recreates and object corresponding the XML string at block  322 . If appropriate, the state of MBeans are stored at block  324  so that the state can be persistent in the event that a subsequent request requires that current state. This is only applicable to platforms where the MBeans and MBeans server are recreated with each request. 
     Elements of embodiments may also be provided as a machine-readable medium for storing the machine-executable instructions. The machine-readable medium may include, but is not limited to, flash memory, optical disks, CD-ROMs, DVD ROMs, RAMs, EPROMs, EEPROMs, magnetic or optical cards, or other types of machine-readable media suitable for storing electronic instructions. Some embodiments of the invention may be downloaded as a computer program which may be transferred from a remote computer (e.g., a server) to a requesting computer (e.g., a client) by way of data signals embodied in a carrier wave or other propagation medium via a communication link (e.g., a modem or network connection). 
     It should be appreciated that reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Therefore, it is emphasized and should be appreciated that two or more references to “an embodiment” or “one embodiment” or “an alternative embodiment” in various portions of this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures or characteristics may be combined as suitable in one or more embodiments of the invention. 
     In the foregoing specification, the invention has been described with reference to the specific embodiments thereof. It will, however, be evident that various modifications and changes can be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.