|
Developing WMI Solutions
Windows Management Instrumentation (WMI) is an impressive technology. For the first time the Windows Operating System employs a unified technology to represent software and hardware management. The power of WMI in systems management stretches to virtually every piece of software and hardware. So regardless of whether you're a team leader, software
engineer or system administrator, WMI will probably affect you.
Many applications written for Windows currently don't harness the power of a systems management technology (like WMI); this is what drove us to write this book. We want developers to realize that making an application manageable is a key benefit, especially to system administrators. Once system administrators and IT support departments realize what can be done with WMI, they will start demanding that applications expose WMI management interfaces. Not only will system administrators be happy, but you'll be able to harvest a wealth of information available from WMI when building your own management applications. The other side of the coin apart from making an application manageable is a 'management application.' A management application is a program (like an MMC snap-in) or web interface that can interact with the system to gather, inspect and manipulate the systems functionality or configuration. We also want system administrators to realize what they can do in a system equipped with a technology like WMI and how they should go about automating routine tasks.
We are both very excited about WMI and hope to spread the word to help the computing world become a more managed place.
contents:
Preface.
1-Introduction.
Structure of the book.
Pedagogical elements.
Target audience.
Pre-requisites.
Terminology.
Software requirements.
Operating system requirements.
Hardware requirements.
Introducing WBEM.
WBEM's basic objectives.
Core objectives.
The central information store.
The Common Information Model.
Object orientation and CIM.
Building an information model.
Structure of the centralised repository.
The three tiered model.
Acronyms and terminology.
Standards bodies.
Motivation.
De facto and De Jure standards.
The Distributed Management Task Force (DMTF).
The World Wide Web Consortium (W3C).
Web Based Enterprise Management (WBEM).
Windows Management Instrumentation (WMI).
Common Information Model (CIM).
Common Information Model repository.
Managed Object Format (MOF).
Simple Network Management Protocol (SNMP).
Common Management Information Services (CMIS).
Common Management Information Protocol (CMIP).
Desktop Management Interface (DMI).
XML (eXtensible Mark-up Language).
Hyper Text Transfer Protocol (HTTP).
Extended schemas.
WMI scripting.
Conclusion.
Web Based Enterprise Management: 10 Fast Facts.
2-Existing Management Frameworks.
New and old technologies combined.
The need for a universal management model.
The Simple Network Management Protocol.
A simple solution to a complex problem.
The SNMP NetworkManagement Station.
Relevant SNMP standards.
Structure of an SNMP message.
Communities.
Event notification-SNMP traps and informs.
The Management Information Base (MIB).
SNMP security.
Modus Operandi.
Advantages of the SNMP protocol.
Disadvantages of the SNMP protocol.
The Desktop Management Interface (DMI).
The DMI Information Model-The management store.
Policy.
Notification of events.
DMI security.
MIF database security.
Management Interface Security.
Component Interface Security.
Security indications.
Advantages of DMI.
Disadvantages of the DMI.
Conclusion.
Common elements for management frameworks.
The need for a unified management framework.
3-Windows Management Instrumentation.
The Standard WBEM components.
Installation.
Installation files.
Configuring Windows 98 for WMI.
Core components of WMI.
WinMgmt.exe-The Windows Management Service.
Mofcomp.exe-The Microsoft MOF compiler.
The WMI Control.
Windows Management Instrumentation Tester.
Automatic MOF registration.
WMI log files.
WMI CIM repository.
Windows Management Instrumentation.
The basic framework of WMI.
WMI management applications.
Direct access.
Indirect access.
Providers.
Types of providers.
Event providers.
Data providers.
Event handling.
Intrinsic events.
Extrinsic events.
Timer events.
Event consumer.
Temporary consumers.
Permanent consumers.
WMI security.
Authentication.
WMI permission assignment using WMI Control.
WMI security on Windows 9x.
The WMI Query Language WQL.
Data queries.
Event queries.
Schema queries.
Conclusion.
4-A guided tour of the Common Information Model Repository.
Meta-data.
Dynamic and static data.
Dynamic data and the CIM repository.
The Common Information Model.
The Core Model.
The Common Model.
The Extended schemas.
Namespaces.
Using the CIMV2 namespace.
WMI Namespaces and the CIM repository.
Defining and using your own namespace.
Namespaces and schemas.
Using existing schemas.
Subclassing and instantiating existing classes in the CIMV2 namespace.
Modifying existing classes.
Managed Object Format.
MOF class declaration.
Qualifiers.
Flavors.
Custom qualifiers.
User-defined qualifiers.
Intrinsic data types.
Instance creation.
Aliasing.
A compileable MOF file.
ActiveX components.
Let the tour begin!.
The class explorer explained.
Associations.
Key Propagation.
Namespaces and associations.
System properties.
Object and property qualifiers.
CIM Studio functions.
Help for a class.
Browse for a namespace.
Searching for a class.
Instance enumeration.
Changing the view (system properties and inherited properties).
WQL queries tool.
Adding a class.
Creating an association.
Deleting a class or association.
Deleting a property.
Adding an instance.
Deleting an instance.
Places of Interest within the CIM repository.
The provider classes.
The namespace classes.
Creating a namespace.
Deleting a namespace.
Tutorial - creating a namespace, adding classes, properties and an association.
The wizards.
The MOF generator.
The MOF compiler.
The provider code generator.
Conclusion.
CIM Repository: 10 Fast Facts.
5-Developing Class Schemas.
Who is the chapter for?.
Schema design and system manageability.
Case study client/server email package.
Basic functionality.
System requirements for Post Office email system.
The Unified Modelling Language.
Further reading in UML.
Learning the CIM schema and Win32 extended schemas.
Psychological requirements.
Schema design timescales.
Software application lifecycle.
The Windows Installer and WMI.
The role of WMI with standard software applications and management software applications.
Schema design in teams vs. single developers.
When should I commit my design to UML?.
Can I design a schema without UML?.
The Unified Modelling Language in schema design.
A brief introduction to UML Object Modelling.
Inheritance notation.
Association notation.
Aggregate associations.
Interpreting the Common Model in UML.
The schema design roadmap.
Basic rules for schema design.
Telephone operator example.
WMI topology design.
First approach.
Second approach.
Schema design phase.
Step 1-Information Gathering.
Collate management specific information.
Ascertain your management data consumers.
Step 2-Define System requirements, Rules and Assertions.
Use Case diagrams and Use Case details.
Rules and assertions.
Step 3-Define classes and properties.
Name your schema.
Define candidate classes.
Define events.
An example intrinsic event filter.
Define statistical classes.
Define settings classes.
Define properties.
Class PO_PostOffice.
Class PO_PostOfficeSettings.
Class PO_UserDetails.
Class PO_EmailAccount.
Class PO_Mailbag.
Class PO_MessageSettings.
Class PO_PostOfficeStats.
Step 4-Define associations.
The purpose of associations.
Representing the PostOffice schema in UML.
Conclusion.
Starting Schema Design Tips.
6-Method design and schema class positioning.
Properties versus Methods.
Methods, operations and functions.
Step 5-Define methods.
Candidate methods.
Method arguments.
Method overriding and polymorphism.
The PostOffice schema methods.
Method AddUser.
Method RemoveUser.
Method UnlockAccount.
Method LockAccount.
Method StopPostOffice.
Method StartPostOffice.
PostOffice schema UML diagram with methods.
Step 6-Schema design checkpoint.
Rule generation based UML diagrams.
Final considerations-future additions.
Final Step-positioning classes.
Step-by-step CIMV2 namespace class positioning.
Extending the CIMV2 namespace.
Normalisation.
CIMV2 class placement objectives.
Putting class placement theory into practice.
Namespace and schema placement.
The Applications namespace.
Limitations of multi-namespace class positioning.
PostOffice schema namespace positioning.
The PostOffice schema class positions.
Managed Object Format (MOF) qualifiers and flavors.
MOF creation and testing.
Implementing the schema: WMI API calls vs. MOF code.
Multi-language support.
The PostOffice schema in MOF.
Compiling a multi-language MOF file.
Testing.
Schema Deployment.
Conclusions.
Schema design and positioning Q&A.
7-Developing Management Applications.
Getting Started.
Object paths explained.
Getting an object.
Enumerating objects.
Creating an object.
Updating objects.
Deleting an object.
Performing queries.
Making method calls.
Manipulating object properties.
Manipulating array object properties.
Accessing objects from object properties.
Making semi synchronous calls.
Making asynchronous calls.
WMI error messages.
Overview of events.
Intrinsic events.
Extrinsic events.
Timer events.
How to subscribe to events.
Writing applications to receive semi synchronous events.
Writing applications to receive asynchronous events.
More on security.
Classes that require specific security privileges.
Localized namespaces.
Overview of Hi-Performance classes.
Writing applications to access Hi-Performance data.
Access Hi-Performance enumerated data.
Summary.
8-Developing .NET Management Applications.
Getting Started.
Getting a management object.
Enumerating management objects.
Creating a management object.
Updating management objects.
Deleting a management object.
Performing queries.
Making method calls.
Manipulating management object properties.
Manipulating array object properties.
Accessing objects from object properties.
Making asynchronous calls.
Overview of events.
Writing applications to receive asynchronous events.
Writing applications to receive semi synchronous events.
Managing connections to WMI.
Summary.
9-Developing MMC Snap-ins.
Snap-in architecture.
Getting started.
Snap-in implementation basics.
Let's make a snap-in.
Implementing IComponentData.
Implementing IComponent.
The root item (and general item basics).
Adding your own namespace items.
Adding your own columns.
Adding your own result items.
Setting up and handling verbs.
Adding your own menus.
Adding your own toolbars.
Adding your own property pages.
Refocusing an item's property sheet.
Adding your own help.
Snap-in about information.
Primary (standalone) snap-in registration.
More on how ATL delegates tasks to an item.
Renaming items.
Drag and drop.
Accessing Web Sites.
Displaying custom views.
Developing extension snap-ins.
Exchanging information between primary and extension snap-ins.
Extension snap-in registration.
Making MMC snap-ins theme aware.
Summary.
10-Developing WMI Scripts for Administrators.
Scripting, WMIC and the CIM Studio.
Administration and the WMI CIM Studio.
Administration and the WMIC.
Administration and scripting.
Guiding principles.
Prerequisites.
Chapter structure.
VBScript Boot Camp.
JavaScript versus VBScript.
Setting up your system for scripting.
Scripting and administration.
What is the Windows Scripting Host?.
Scripts.
Scripting versus compiled languages.
The Windows Scripting Host.
Your first script.
Indentation.
Annotation.
Variants, variables and constants.
Use meaningful variable names.
VBScript functions.
The WSH Object Model.
Program statements and keywords.
The option explicit statement.
Connecting to a local or remote namespace.
Security issues.
Deciding on the level of security required.
Data input.
Error detection.
Error logging (NT/2000/XP only).
WMI scripting data retrieval.
Displaying date and time values (XP only).
Retrieving subsets of instances.
WMI data modification scripting example.
Data deletion scripting example.
Data creation scripting example.
Association traversal using VBScript.
Executing methods using VBScript.
Conclusions.
Summary of VBScript boot camp: 10 Fast Facts.
11-WMI Scripting and WMIC.
Identifying the correct course of action.
Make a note of the problem description.
Divide the problem into its constituent parts.
Decide which hardware or software component(s) you are going to manage.
Which tool?.
Decide on whether your script should run locally or remotely on the target machine(s).
Decide if your script will run unattended or attended.
Determine the variables and constants.
Candidate Constants.
Candidate Variables.
Determine the sequence of steps in the task.
Script deployment and execution.
Local execution and storage.
Local execution from a shared resource.
Remote connection across a network.
Remote invocation of a script (only available with Windows Script v5.6).
Script execution methods.
Executing scripts at start-up.
Execute the script using the Windows Scheduler.
Event driven script execution (Windows XP only).
Sending Email.
Setting up your system for debugging and testing.
Debugging your scripts.
Windows Management Instrumentation Command-line (WMIC).
Using WMIC.
Interactive mode.
Configuring WMIC.
Interacting with WMIC.
The WHERE clause.
Verbs.
Adverbs.
Looping WMIC commands.
Types of output.
Aliases.
Creating or modifying Aliases using the CIM studio.
Using WMIC in non-interactive mode.
Summary.
12-Developing WMI Providers.
Where to start.
Developing an instance provider.
Provider registration.
Provider initialization.
Enumerating objects.
Getting an object.
Deleting an object.
Creating or updating an object.
Querying for your objects.
Instance provider registration.
Developing a method provider.
Executing methods.
Method provider registration.
Developing an event provider.
Firing events.
Event provider registration.
Developing an event consumer provider.
Handling event notifications.
Permanent event consumer provider registration.
Developing a property provider.
Exposing dynamic properties.
Property provider registration.
Developing a push provider.
Pushing data to the CIM Repository.
Push provider registration.
Security considerations.
Summary.
13-High Performance Instrumentation.
Overview of Event Tracing.
Controlling Event Traces.
Starting a Kernel event tracing session.
Setting up a session's configuration.
Querying the session's configuration and statistics.
Stopping the session.
Starting event tracing sessions.
Querying for active event tracing sessions.
Querying for registered event tracing providers.
Starting private event tracing sessions.
Developing an event tracing provider.
Defining the event class schema.
Registering an application as an event tracing provider.
Developing the provider's control call-back function.
Producing an event trace.
Producing an hierarchical event trace.
Analysing event trace log files.
Processing an event trace log file.
The event call-back function.
The buffer call-back function.
The consumer event tracing APIs.
Monitoring real-time event tracing sessions.
Providing and analysing lightweight events.
Analysing lightweight events.
Summary.
Appendix A-WMI Event SDK Tools.
Glossary.
Bibliography.
Index.
|
