Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbAccess/BdbAuth.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbAuth.cc,v 1.35 2002/06/21 18:30:18 ryd Exp $
//
// Description:
//      This class provides an access to and management of the BaBar
//      Database athorization records.
//
//      The class is implemented as a singleton.
//
//      NOTE: This is a proxy class deffering the real authorization
//            requests to the BdbAuthFederation objects.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko       Original Author
//
// History:
//      Copyright (C) 2001      Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------

        /////////////////////////
        // This Class's Header //
        /////////////////////////

#include "BdbAccess/BdbAuth.hh"

        ///////////////
        // C Headers //
        ///////////////

        /////////////////
        // C++ Headers //
        /////////////////

#include <iostream.h>
#include <string>
using std::string;
#include <map>
using std::map;

        /////////////////////////////////
        // Collaborating Class Headers //
        /////////////////////////////////

#include "BdbAccess/BdbAuthFederation.hh"
#include "BdbAccess/BdbAuthUsersItr.hh"
#include "BdbAccess/BdbAuthGroupsItr.hh"

        ////////////////////////
        // External functions //
        ////////////////////////

extern void BaBarObjyMessageHandler(char*);
extern ooStatus BaBarObjyErrorHandler(ooErrorLevel, ooError&, ooHandle(ooObj)*, char*);


        /////////////////////////////////////////////////////////////////////////
        // Local Macros, Typedefs, Structures, Unions and Forward Declarations //
        /////////////////////////////////////////////////////////////////////////

static const char rcsid[] = "$Id: BdbAuth.cc,v 1.35 2002/06/21 18:30:18 ryd Exp $";


        ////////////////////////////////////
        // Static Data Member Definitions //
        ////////////////////////////////////

BdbAuth*
BdbAuth::_instance = 0;

        ////////////////////////
        // Singleton Selector //
        ////////////////////////

BdbAuth* 
BdbAuth::instance( )
{
    if( 0 == _instance ) _instance = new BdbAuth( );
    return _instance;
}

        ////////////////
        // Destructor //
        ////////////////

BdbAuth::~BdbAuth( )
{
    map<string, BdbAuthFederation*>::iterator theItr=_federation->begin();
    while( theItr!=_federation->end()) {
      delete theItr->second;
      theItr++;
    }
    delete _federation;
}

        /////////////////
        // Constructor //
        /////////////////

BdbAuth::BdbAuth( )
{
    _federation = new map<string, BdbAuthFederation*>;
}

        ///////////////
        // Selectors //
        ///////////////

d_Boolean
BdbAuth::isInitialized( BdbDomain::Domains theDomain )
{
    return federationInstance( )->isInitialized( theDomain );
}

d_Boolean
BdbAuth::isAuthorized( BdbDomain::Domains    theDomain,
                       BdbDomain::AuthLevels theAuthLevel,
                       const char* const     theAuthName )
{
    return federationInstance( )->isAuthorized( theDomain,
                                                theAuthLevel,
                                                (const char*)theAuthName );
}

d_Boolean
BdbAuth::isSystemManager( BdbDomain::Domains theDomain,
                          const char*        theUserName )
{
    return federationInstance( )->isSystemManager( theDomain,
                                                   theUserName );
}

d_Boolean
BdbAuth::isGroupManager( BdbDomain::Domains theDomain,
                         const char*        theUserName,
                         const char*        theGroupName )
{
    return federationInstance( )->isGroupManager( theDomain,
                                                  theUserName,
                                                  theGroupName );
}

d_Boolean
BdbAuth::isGroupMember( BdbDomain::Domains theDomain,
                        const char*        theUserName,
                        const char*        theGroupName )
{
    return federationInstance( )->isGroupMember( theDomain,
                                                 theUserName,
                                                 theGroupName );
}

d_Boolean
BdbAuth::isDomainMember( BdbDomain::Domains theDomain,
                         const char*        theUserName )
{
    return federationInstance( )->isDomainMember( theDomain,
                                                  theUserName );
}

d_Boolean
BdbAuth::isAccessAllowed( BdbDomain::Domains theDomain,
                          const char*        theUserName )
{
    return federationInstance( )->isAccessAllowed( theDomain,
                                                   theUserName );
}

const char*
BdbAuth::getUserDescription( BdbDomain::Domains theDomain,
                             const char*        theUserName )
{
    return federationInstance( )->getUserDescription( theDomain,
                                                      theUserName );
}

const char*
BdbAuth::getUserCreated( BdbDomain::Domains theDomain,
                         const char*        theUserName )
{
    return federationInstance( )->getUserCreated( theDomain,
                                                  theUserName );
}

const char*
BdbAuth::getGroupDescription( BdbDomain::Domains theDomain,
                              const char*        theGroupName )
{
    return federationInstance( )->getGroupDescription( theDomain,
                                                       theGroupName );
}

const char*
BdbAuth::getGroupCreated( BdbDomain::Domains theDomain,
                          const char*        theGroupName )
{
    return federationInstance( )->getGroupCreated( theDomain,
                                                   theGroupName );
}

        ////////////////
        // Operations //
        ////////////////

d_Boolean
BdbAuth::initialize( BdbDomain::Domains theDomain )
{
    return federationInstance( )->initialize( theDomain );
}

d_Boolean
BdbAuth::createUser( BdbDomain::Domains    theDomain,
                     BdbDomain::AuthLevels theAuthLevel,
                     const char*           theUserName,
                     const char*           theGroupName,
                     const char*           theDescription )
{
    return federationInstance( )->createUser( theDomain,
                                              theAuthLevel,
                                              theUserName,
                                              theGroupName,
                                              theDescription );
}

d_Boolean
BdbAuth::deleteUser( BdbDomain::Domains theDomain,
                     const char*        theUserName )
{
    return federationInstance( )->deleteUser( theDomain,
                                              theUserName );
}

d_Boolean
BdbAuth::createGroup( BdbDomain::Domains theDomain,
                      const char*        theGroupName,
                      const char*        theDescription )
{
    return federationInstance( )->createGroup( theDomain,
                                               theGroupName,
                                               theDescription );
}

d_Boolean
BdbAuth::deleteGroup( BdbDomain::Domains theDomain,
                      const char*        theGroupName )
{
    return federationInstance( )->deleteGroup( theDomain,
                                               theGroupName );
}

d_Boolean
BdbAuth::includeUser( BdbDomain::Domains theDomain,
                      const char*        theUserName,
                      const char*        theGroupName )
{
    return federationInstance( )->includeUser( theDomain,
                                               theUserName,
                                               theGroupName );
}

d_Boolean
BdbAuth::excludeUser( BdbDomain::Domains theDomain,
                      const char*        theUserName,
                      const char*        theGroupName )
{
    return federationInstance( )->excludeUser( theDomain,
                                               theUserName,
                                               theGroupName );
}

d_Boolean
BdbAuth::deleteDomain( BdbDomain::Domains theDomain )
{
    return federationInstance( )->deleteDomain( theDomain );
}

d_Boolean
BdbAuth::setSystemManager( BdbDomain::Domains theDomain,
                           const char*        theUserName,
                           d_Boolean          onOff )
{
    return federationInstance( )->setSystemManager( theDomain,
                                                    theUserName,
                                                    onOff );
}

d_Boolean
BdbAuth::setGroupManager( BdbDomain::Domains theDomain,
                          const char*        theUserName,
                          const char*        theGroupName,
                          d_Boolean          onOff )
{
    return federationInstance( )->setGroupManager( theDomain,
                                                   theUserName,
                                                   theGroupName,
                                                   onOff );
}

        ////////////////////////////
        // Transaction management //
        ////////////////////////////

void
BdbAuth::startUpdate( )
{
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    theApp->startUpdate( "Authorization" );
}

void
BdbAuth::startRead( )
{
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    theApp->startRead( "Authorization" );
}

void
BdbAuth::abort( )
{
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    theApp->abort( "Authorization" );
}

void
BdbAuth::commit( )
{
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    theApp->commit( "Authorization" );
}

        ///////////////////////
        // Iterators factory //
        ///////////////////////

BdbAuthItr*
BdbAuth::createUsersItr( BdbDomain::Domains theDomain )
{
    BdbAuthFederation* theAuthFederation = federationInstance( );
    BdbAuthUsersItr* theItr = new BdbAuthUsersItr( theAuthFederation,
                                                   theDomain );
    if( !theItr->isValid( )) {

        delete theItr;

        error( theAuthFederation->getName( ).c_str(),
               theDomain,
               "Failed to setup a users iterator to iterate all users in the domain." );

        return 0;
    }
    return theItr;
}

BdbAuthItr*
BdbAuth::createUsersItr( BdbDomain::Domains theDomain,
                         const char*        theGroupName )
{
    BdbAuthFederation* theAuthFederation = federationInstance( );
    BdbAuthUsersItr* theItr = new BdbAuthUsersItr( theAuthFederation,
                                                   theDomain,
                                                   theGroupName );
    if( !theItr->isValid( )) {

        delete theItr;

        error( theAuthFederation->getName( ).c_str(),
               theDomain,
               "Failed to setup a users iterator to iterate all users in a group." );

        return 0;
    }
    return theItr;
}

BdbAuthItr*
BdbAuth::createGroupsItr( BdbDomain::Domains theDomain )
{
    BdbAuthFederation* theAuthFederation = federationInstance( );
    BdbAuthGroupsItr* theItr = new BdbAuthGroupsItr( theAuthFederation,
                                                     theDomain );
    if( !theItr->isValid( )) {

        delete theItr;

        error( theAuthFederation->getName( ).c_str(),
               theDomain,
               "Failed to setup a users iterator to iterate all groups in the domain." );

        return 0;
    }
    return theItr;
}

BdbAuthItr*
BdbAuth::createGroupsItr( BdbDomain::Domains theDomain,
                          const char*        theUserName )
{
    BdbAuthFederation* theAuthFederation = federationInstance( );
    BdbAuthGroupsItr* theItr = new BdbAuthGroupsItr( theAuthFederation,
                                                     theDomain,
                                                     theUserName );
    if( !theItr->isValid( )) {

        delete theItr;

        error( theAuthFederation->getName( ).c_str(),
               theDomain,
               "Failed to setup a users iterator to iterate all groups a user is member of." );

        return 0;
    }
    return theItr;
}

        ////////////////////////
        // Messages reporting //
        ////////////////////////

void
BdbAuth::message( const char*        theBootFileName,
                  BdbDomain::Domains theDomain,
                  const char*        theMessage )
{
    cout << "BdbAuth::message() " << theMessage << endl
         << "    FEDERATION: " << theBootFileName << endl
         << "    DOMAIN:     " << BdbDomain::domainName( theDomain ) << endl;
}

void
BdbAuth::warning( const char*        theBootFileName,
                  BdbDomain::Domains theDomain,
                  const char*        theMessage )
{
    cout << "BdbAuth::warning() " << theMessage << endl
         << "    FEDERATION: " << theBootFileName << endl
         << "    DOMAIN:     " << BdbDomain::domainName( theDomain ) << endl;
}

void
BdbAuth::error( const char*        theBootFileName,
                BdbDomain::Domains theDomain,
                const char*        theMessage )
{
    cout << "BdbAuth::error() " << theMessage << endl
         << "    FEDERATION: " << theBootFileName << endl
         << "    DOMAIN:     " << BdbDomain::domainName( theDomain ) << endl;
}

void
BdbAuth::fatal( const char*        theBootFileName,
                BdbDomain::Domains theDomain,
                const char*        theMessage,
                int                exitCode )
{
    cout << "BdbAuth::fatal() " << theMessage << endl
         << "    FEDERATION: " << theBootFileName << endl
         << "    DOMAIN:     " << BdbDomain::domainName( theDomain ) << endl;

    exit( exitCode );
}

        ///////////////////////////////////////
        // Federations dictionary management //
        ///////////////////////////////////////

BdbAuthFederation*
BdbAuth::federationInstance( )
{
  // Get the BOOT file name if possible. Use an empty string if not found.

    const char* theBootFileName = "";

    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    if( 0 != theApp && 0 != theApp->bootName( )) {
        theBootFileName = theApp->bootName( );
    }

  // Locate/create a federation instance for that BOOT file name.

    if( _federation->find( theBootFileName )==_federation->end()) {
        (*_federation)[theBootFileName] = new BdbAuthFederation( theBootFileName );
    }

    return (*_federation)[theBootFileName];
}

/////////////////
// End Of File //
/////////////////

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002