Abstract: Installation, build, and operation information on the OpenPegasus . 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
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
separately. You can use
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
here on our Nightly
Build and Test Status page. The Release Notes for each
(pegasus/ReleaseNotes.htm) provide additional details
regarding the platforms, compilers, etc. 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. Note that all of the dependencis listed below are required only if selected options are enabled except for GNUMAKE which is the required make tool:
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
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 differences between Windows and other platforms in starting the CIMserver 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
OpenPegasus functionality, changes, plans, etc. The approved
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 CVS doc directory and the pegasus CVS root as readme files. Also, there is a set of Release Notes for each release in the OpenPegasus root source directory of CVS and as a Pegasus PEP.
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
executables instead of building from source code, then refer to the RPM installation
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,
OpenPegasus, some environment variables may
have to be defined or updated. See PEP 292 for the full list
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.
can also compile MOF (Managed Object Format) code manually with the
The 'make repository' target in the makefile pegasus/Makefile performs several functions including:
OpenPegasus registers Providers using a set of provider registration classes encoded in MOF. This classes are proprietary to OpenPegasus today.
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 pegasus/src/Providers/sample/Load directory for examples of several registration instance implementations that do work with OpenPegasus today.
Registration may be performed by creating compiling the registration mof with either the on-line or off-line Pegasus mof compiler. It is recommended that providers be registered with the on-line compiler because this allows pegasus to validate the registration information.
To build OpenPegasus on Linux, ensure that you you have the necessary environment variables set (eg. PEGASUS_HOME, PEGASUS_ROOT, PEGASUS_PLATFORM). For 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:
component is what forms the PEGASUS_PLATFORM environment variable so
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 mulitple windows platforms.
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 (This utility allows use of unix command line semantics for certain operations in windows). 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
REM (Note: The '/' characters are intentional and required by the OpenPegasus build system).
REM Also the disk designator (C:) is required for at least some newer versions of the Microsoft
REM compilers to avoid confusion between options and paths
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.
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
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
Licensed to The Open Group (TOG) under one or more contributor license agreements. Refer to the OpenPegasusNOTICE.txt file distributed with this work for additional information regarding copyright ownership. Each contributor licenses this file to you under the OpenPegasus Open Source License; you may not use this file except in compliance with the License.
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.