wet_schema.mof

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

     "point for Services, that are each located on a single "
     "host.") ] 
class WET_HostedService : WET_Dependency {
      [Override ("Antecedent"), Max (1), Min (1),
       Description ("The hosting System.") ] 
   WET_System REF Antecedent;
      [Override ("Dependent"), Weak,
       Description ("The Service hosted on the System.") ] 
   WET_Service REF Dependent;
};

     
// ==================================================================
//    HostedAccessPoint
// ==================================================================
   [Association, Description (
     "WET_HostedAccessPoint is an association between a Service"
     "AccessPoint and the System on which it is provided.  The "
     "cardinality of this association is 1-to-many and is weak "
     "with respect to the System. Each System may host many "
     "ServiceAccessPoints.  Heuristic:  If the implementation of "
     "the ServiceAccessPoint is modeled, it must be "
     "implemented by a Device or SoftwareFeature that is part of "
     "the System hosting the ServiceAccessPoint.") ] 
class WET_HostedAccessPoint:WET_Dependency {
      [Override ("Antecedent"), Max (1), Min (1), 
       Description ("The hosting System.") ] 
   WET_System REF Antecedent;
      [Override ("Dependent"), Weak,
       Description ("The SAP(s) that are hosted on this System.") ] 
   WET_ServiceAccessPoint REF Dependent;
};
   

// ==================================================================
//    ProvidesServiceToElement
// ==================================================================
   [Association, Description (
     "WET_ProvidesServiceToElement is used to describe that "
     "ManagedElements may be dependent on the functionality "
     "of one or more Services. An example is that a Processor "
     "and an Enclosure (PhysicalElement) are dependent on AlertOn"
     "LAN Services to signal an incomplete or erroneous boot, and "
     "hardware-related errors.") ]
class WET_ProvidesServiceToElement : WET_Dependency {
      [Override ("Antecedent"), Description (
        "The Service provided.") ]
   WET_Service ref Antecedent;
      [Override ("Dependent"), Description (
        "The ManagedElement dependent on the Service.") ]
   WET_ManagedElement ref Dependent;
};


// ==================================================================
//    ServiceServiceDependency
// ==================================================================
   [Association, Description (
     "WET_ServiceServiceDependency is an association between a " 
     "Service and another Service, indicating that the latter is "
     "required to be present, required to have completed, or must " 
     "be absent for the former Service to provide its "
     "functionality. For example, Boot Services may be dependent "
     "upon underlying BIOS Disk and initialization Services. "
     "In the case of the initialization Services, the Boot Service "
     "is simply dependent on the init Services completing.  For "
     "the Disk Services, Boot Services may actually utilize the "
      "SAPs of this Service.  This usage dependency is modeled via "
     "the WET_ServiceSAPDependency association.") ] 
class WET_ServiceServiceDependency : WET_ProvidesServiceToElement {
      [Override ("Antecedent"), 
       Description ("The required Service.") ] 
   WET_Service REF Antecedent;
      [Override ("Dependent"), Description (
        "The Service that is dependent on an underlying Service.") ] 
   WET_Service REF Dependent;
      [Description (
        "The nature of the Service to Service dependency. This "
        "property describes that the associated Service must have "
        "completed (value=2), must be started (3) or must not be "
        "started (4) in order for the Service to function."),  
       Values {"Unknown", "Other", "Service Must Have Completed",
               "Service Must Be Started", 
               "Service Must Not Be Started"} ]
   uint16 TypeOfDependency;
      [Description(
        "this property describes that the antecedent service "
        "must be restarted after the dependent operation is complete.")]
   boolean RestartService;
};


// ==================================================================
//    ServiceSAPDependency
// ==================================================================
   [Association, Description (
     "WET_ServiceSAPDependency is an association between a Service "
     "and a ServiceAccessPoint indicating that the referenced SAP "
     "is utilized by the Service to provide its functionality. For "
     "example, Boot Services may invoke BIOS' Disk Services "
     "(interrupts) in order to function.") ] 
class WET_ServiceSAPDependency : WET_Dependency {
      [Override ("Antecedent"), 
       Description ("The required ServiceAccessPoint") ] 
   WET_ServiceAccessPoint REF Antecedent;
      [Override ("Dependent"), Description (
        "The Service that is dependent on an underlying SAP.") ] 
   WET_Service REF Dependent;
};

     
// ==================================================================
//    SAPSAPDependency
// ==================================================================
   [Association, Description (
     "WET_SAPSAPDependency is an association between a Service"
     "AccessPoint and another ServiceAccessPoint indicating that "
     "the latter is required in order for the former ServiceAccess"
     "Point to utilize or connect with its Service. For example, "
     "to print at a network printer, local Print Access Points "
     "must utilize underlying network-related SAPs, or "
     "ProtocolEndpoints, in order to send the print request.") ] 
class WET_SAPSAPDependency:WET_Dependency {
      [Override ("Antecedent"), Description (
        "The required ServiceAccessPoint.") ] 
   WET_ServiceAccessPoint REF Antecedent;
      [Override ("Dependent"), Description (
        "The ServiceAccessPoint that is dependent on an underlying "
        "SAP.") ] 
   WET_ServiceAccessPoint REF Dependent;
};


// ==================================================================
//    Realizes
// ==================================================================
   [Association, Description (
     "WET_Realizes is the association that defines the mapping "
     "between a Logical Device and the physical component that "
     "implements the Device.") ] 
class WET_Realizes : WET_Dependency {
      [Override ("Antecedent"), Description (
        "The physical component that implements the Device.") ]
   WET_PhysicalElement REF Antecedent;
      [Override ("Dependent"), Description (
        "The LogicalDevice.") ]
   WET_LogicalDevice REF Dependent;
};

     
// ==================================================================
//    Component
// ==================================================================
   [Association, Abstract, Aggregation, Description (
     "WET_Component is a generic association used to establish "
     "'part of' relationships between Managed System Elements. For "
     "example, the SystemComponent association defines parts of "
     "a System.") ] 
class WET_Component {
      [Aggregate, Key, Description (
        "The parent element in the association.") ] 
   WET_ManagedSystemElement REF GroupComponent;
      [Key, Description (
        "The child element in the association.") ] 
   WET_ManagedSystemElement REF PartComponent;
};

     
// ==================================================================
//    SystemComponent
// ==================================================================
   [Association, Aggregation, Description (
     "WET_SystemComponent is a specialization of the WET_Component "
     "association that establishes 'part of' relationships between "
     "a System and the Managed System Elements of which it is "
     "composed.") ] 
class WET_SystemComponent : WET_Component {
      [Override ("GroupComponent"), Aggregate, 
       Description ("The parent System in the Association.") ] 
   WET_System REF GroupComponent;
      [Override ("PartComponent"), Description (
        "The child element that is a component of a System.") ] 
   WET_ManagedSystemElement REF PartComponent;
}; 
     
// ==================================================================
//    SystemDevice
// ==================================================================
   [Association, Aggregation, Description (
     "LogicalDevices may be aggregated by a System.  This " 
     "relationship is made explicit by the SystemDevice "
     "association. ") ]
class WET_SystemDevice:WET_SystemComponent {
      [Override ("GroupComponent"), Aggregate, Max (1), Min (1), 
       Description ("The parent system in the Association.") ] 
   WET_System REF GroupComponent;
      [Override ("PartComponent"), Weak, Description (
        "The LogicalDevice that is a component of a System.") ] 
   WET_LogicalDevice REF PartComponent;
};


// ==================================================================
//    ServiceComponent
// ==================================================================
   [Association, Aggregation, Description (
     "The ServiceComponent aggregation models a set of "
     "subordinate Services that are aggregated together to form "
     "a higher-level service.") ]
class WET_ServiceComponent : WET_Component {
      [Override ("GroupComponent"), Aggregate, 
       Description ("The parent Service.") ]
   WET_Service REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The component Service.") ]
   WET_Service REF PartComponent;
};

     
// ==================================================================
//    Synchrononized
// ==================================================================
   [Association, Description (
     "Indicates that two LogicalElements were aligned or made to "
     "be equivalent at the specified point in time. If the boolean "
     "property SyncMaintained is TRUE, then synchronization "
     "of the Elements is preserved. Both like and unlike objects "
     "may be synchronized. For example, two WatchDog timers may be "
     "aligned, or the contents of a LogicalFile may be synchronized "
     "with the contents of a StorageExtent.") ]
class WET_Synchronized {
      [Key, Description (
        "SystemElement represents one LogicalElement that is "
        "synchronized with the entity referenced as SyncedElement.") ]
   WET_LogicalElement ref SystemElement;
      [Key, Description (
        "SyncedElement represents another LogicalElement that is "
        "synchronized with the entity referenced as SystemElement.") ]
   WET_LogicalElement ref SyncedElement;
      [Description (
        "The point in time that the Elements were synchronized.") ]
   datetime WhenSynced;
      [Description (
        "Boolean indicating whether synchronization is "
        "maintained.") ]
   boolean SyncMaintained;
};


// ==================================================================
//     AdminDomain
// ==================================================================
   [Description (
     "This is a special grouping of ManagedSystemElements. The "
     "grouping is viewed as a single entity, reflecting that all "
     "of its components are administered similarly - either by "
     "the same user, group of users or policy. It serves as "
     "an aggregation point to associate one or more of the "
     "following elements: network devices, s