Abstract: Installation, build, and operation information on the OpenPegasus Version 2.8.0 Release. Note that if this readme conflicts with the documentation in the release notes or interface definition documents for a particular release, those documents should be considered authoritative. This is a simplified overview to act as an introduction to OpenPegasus.
OpenPegasus - A Manageability Services Broker for the DMTF CIM/WBEM Standards
Tagline: OpenPegasus is an object manager for DMTF CIM objects written in C++ and hosted by The Open GroupOpenPegasus Overview
How to Participate
Download or CheckoutTesting an OpenPegasus installation
Set the Environment Variables
Build the Executables
Populate the Repository
Notes about Building on Linux
Notes about Building on Windows
The MU UtilityNotes about Building with SSL
Testing with ICU enabled
- A DMTF compliant CIM Server that processes CIM operations, CIM Indications, and includes class and instance repositories and interfaces for creating CIM Providers and CIM Clients.
- Provider interfaces so that providers may be build in multiple languages (i.e. C++, C, Java).
- A number of CIM Providers.
- A MOF compiler.
- A number of CIM Clients to provide usage examples, CIM Server test functions, and administrative functions.
- More complete information on the exact functions and their functional state is available from the Release Notes (pegasus/ReleaseNotes.htm) and the OpenPegasus Feature Status Page.
OpenPegasus is being developed and maintained under the auspices of The Open Group. OpenPegasus is maintained under the license defined in the doc directory of this release. The specific file is: pegasus/doc/license.txt. This licensing is intended to support as wide a distribution as possible with minimal demands on the users.
More information on this project, access to the CVS, and documentation is available from the OpenPegasus web site.
that all references in this readme to files in the OpenPegasus source
tree are of the form pegasus/..., where "pegasus" is the top-level
directory and also the name of the OpenPegasus module in the Pegasus CVS
repository. There are also other CVS modules for the OpenPegasus Java client (pegasus-JavaCIMClient)
and for unsupported components and utilities for Pegasus that may be checked out
separately. You can use
viewCVS to view the
Pegasus CVS tree
CVS write accounts are managed by Martin Kirk of The Open Group (firstname.lastname@example.org)
OpenPegasus is regularly tested against a
variety of platforms by the
development group. The results of the nightly tests can be found
here on our Nightly
Build and Test Status page. The Release Notes
(pegasus/ReleaseNotes.htm) provide additional details
regarding the platforms for the current release.
We have worked to minimize the dependence of OpenPegasus on other software packages and tools. Currently OpenPegasus has the following dependencies:
A set of the required
tools for building on the Windows platform is available on the
Pegasus includes the server which can be controlled from the command line and a set of clients that provide adminstrative functions
The manpages for each of the commands are in the pegasus/rpm/manLinux/ directory (from CVS).
To see simple help for each command,
invoke it with the "--help" option.
- Refer to the admin guide in pegasus/doc/Admin_Guide_Release.pdf for more information about administering the OpenPegasus CIM Server.
- There are some differences between Windows and other platforms in starting the server as a daemon/service. Whereas most supported platforms use the OpenPegasus daemon configuration option to start the CIM Server as a daemon, on Windows it must be specifically installed as a service (ex. cimserver -install) and then started as a service (cimserver -start). The cimserver --help option explains the exact format of the start and stop options.
- The cimuser command is used to manage OpenPegasus users only when the CIM Server is compiled without the PEGASUS_PAM_AUTHENTICATION environment variable defined. See PEP 308 for more information on these configuration options.
is documented in the Pegasus
Enhancement Process (PEPs) which are the basis for approval of
OpenPegasus functionality, changes, plans, etc. The approved PEPs
are publicly available on the OpenPegasus web site.
Other documentation available is an api document (creatable from the source tree, see pegasus/doc/apidoc) and other miscellaneous documentation in the doc directory. Also, there is a set of Release Notes for each release in the OpenPegasus root source directory of CVS.
The OpenPegasus web site will be the source of most documentation in the future, and today is the source of most discussion and design documentation.
Contributors are welcome to participate in the OpenPegasus development effort. Join the mailing list by going to the Mailing Lists web page from the OpenPegasus site.
Refer to the Availability
section for instructions on obtaining source code.
If you want to install pre-built Pegasus
executables instead of building from source code, then refer to the RPM installation instructions.
you build, install, or run OpenPegasus, be sure you have the proper set
it depends on. Refer to the section Dependencies
the complete list.
Before building, installing, or running
OpenPegasus, some environment variables may
have to be defined or updated. See PEP 292 for the full list of
environment variables and configuration options for OpenPegasus. The
minimum set is:
Before using OpenPegasus you must populate the repository. Typically,
is done during the build process by the 'make repository' target. However,
can also compile MOF (Managed Object Format) code manually with the
The 'make repository' target in pegasus/Makefile does several things:
OpenPegasus registers Providers using a set of provider registration classes encoded in MOF. This set of classes is close to, but not exactly the same as, the experimental DMTF definition (See the DMTF Interop schema, experimental versions starting with 2.6). This will be harmonized in the future when the DMTF schema is moved to final status.
Registration is performed by creating instances of the registration classes that represent the provider module, providers, capabilities, etc. to be registered. The easiest way to create a new registration today is to copy from one of the existing registration MOFs. See the src/Providers/sample/Load directory for examples of several registration instance implementations that do work with OpenPegasus today.
To build OpenPegasus on Linux, ensure that you you have the necessary
variables set (eg. PEGASUS_HOME, PEGASUS_ROOT, PEGASUS_PLATFORM).
32 bit Linux, the definition of PEGASUS_PLATFORM is normally
LINUX_IX86_GNU. For 64 bit IX86 Linux the definition of
PEGASUS_PLATFORM is normally LINUX_IX86_64_GNU. Use the g++
compiler to compile and link the executables. All of the supported platform
definitions are defined in pegasus/mak as make files with the definition
platform_<operatingSystem>_<architecture>_<compiler>. The <operatingSystem>_<architecture>_<compiler>
component is what forms the PEGASUS_PLATFORM environment variable so that the
appropriate platform make file can be found during the build process.
Use of Windows 2000 SP3 or later is recommended. OpenPegasus is regularly tested on both Windows 2000 and Windows XP using the Microsoft Visual C++ compilers.
Today we build OpenPegasus on Windows using a set of Makefiles contained in the source distribution, the Microsoft compilers (DevStudio 5.x is not supported, Visual Studio 6.0 (SP5) or later is supported) and the GNUMAKE make utility. Note that you MUST have the OpenPegasus mu.exe utility compiled and available before trying to compile OpenPegasus on the normal windows platform. The following is the basic setup steps for the environment.
Setup the environment variables and path for the Micrososft Visual C compiler. Typically this can be done by running the VCVARS32.BAT file supplied with Microsoft Visual C++. (contained in the same directory as cl.exe).
For Windows, try the following for an example environment:
REM call the standard Microsoft .bat for VC 6 setup.
call 'C:/Program Files\Microsoft Visual Studio\VC98\Bin\Vcvars32.bat'
REM Set debug to something if you want to compile in debug mode
REM set PEGASUS_ROOT to top of source tree
set PEGASUS_ROOT=C:/cimom/pegasus (Note: The '/' characters are intentional and required by the OpenPegasus build system)
REM set PEGASUS_HOME to where you want repository and executables, it can be the same as PEGASUS_ROOT
REM set PEGASUS_PLATFORM for Windows
REM setup the path to the runtime files.
In order to provide a consistent build structure across multiple platforms, we developed a utility to provide a consistent set of functions across these platforms. The MU utility is a simple utility that contains many commands. For example:
C:\> mu rm myfile.cpp yourfile.cpp
You may type "mu" to get a list of valid commands. Here are some of them:
rm, rmdirhier, mkdirhier, echo, touch, pwd, copy, move, compare depend
The MU utility supports globing (expansion of wildcards) so you can do things like this:
C:\> mu rm *.obj *.exe
MU is required to build under the Windows
environment. MU is
available as part
of the distribution of OpenPegasus.
To build with SSL you need the OpenSSL libraries and header files. They
are NOT distributed with OpenPegasus. Make sure you have them in a
directory so OpenPegasus can find them. If that's not
the case, set the environment variable OPENSSL_HOME= to point where
installation is (refer to PEP 292
for more details on build variables).
You must also have the PEGASUS_HAS_SSL environment variable defined. Then when you build OpenPegasus, it will include the SSL support.
OpenPegasus includes an extensive set of test facilities as part of the CVS environment, including:
Once OpenPegasus is successfully built, the tests can be executed through the root Makefile with targets such as:
- make unittests - Execute the unit tests. These do not depend on having a running server or repository installed. They test components of the OpenPegasus code. These tests run to completion if successful but normally stop on the first error found by a test program.
- make servertests - Executes the OpenPegasus end-to-end test suite against a running OpenPegasus server starting and stopping the server as required to modify configuration parameters. The repository must be installed for these tests to execute and they are tested against the default repository as part of regular OpenPegasus development and release testing. These tests will run to successful completion if there are not errors detected but will normally stop on the first error. There is a subset of these tests that can be run in an environment that does not have root privileges but root privileges are required to run the complete suite.
- make alltests - execute both the unit and end-to-end tests.
ICU (International Components for
Unicode) refers to the set of
libraries that OpenPegasus uses to run with globalization support. For
libraries are used
load messages in different languages, format currency and numbers
a specific locale etc. In order to enable globalization, OpenPegasus
must be built with ICU enabled, ie. the right environment variables
set prior to running "make". Refer to the GlobalizationHOWTO.htm in the
directory for details.
When users run "make servertests"
to verify the integrity of an OpenPegasus download, a series of tests
require the CIM Server to be running. These tests currently depend on
messages returned from the CIM Server. When ICU is enabled, all
come from the resource bundles and these usually do not match the
hardcoded default messages within OpenPegasus. These hardcoded default
messages are what the various test programs expect in order to complete
successfully. If the ICU-enabled CIM Server is started without
disabling message loading from the bundles, "make servertests"
In order to run "make servertests"
successfully with ICU enabled, an
environment variable called PEGASUS_USE_DEFAULT_MESSAGES must be
starting OpenPegasus. Once
this is defined, when OpenPegasus starts,
messages generated will be the default hardcoded messages. This will
to complete successfully. Once "make
complete, you should stop OpenPegasus and
PEGASUS_USE_DEFAULT_MESSAGES. If this variable is left defined,
will not be able to load messages
using ICU resource bundles.
running the "make unittests"
command with ICU enabled, the PEGASUS_MSG_HOME
environment variable must be set to the home directory where the ICU
resource bundles are built. By default the resource bundles are built
into directories below PEGASUS_HOME/msg, so that should be the setting
Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
EMC Corporation; Symantec Corporation; The Open Group.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.