Admin.cpp

gehe zur Dokumentation dieser Datei

// Copyright (C) 2004 Bernhard Assmann <bernie@tuxomania.net>
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//  
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//  
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//  

#include <iostream>
#include <iterator>
#include <cstdlib>

#include "psfa/Admin.hpp"
#include "psfa/Helper.hpp"
#include "psfa/DbWriteDriverMySql.hpp"
#include "psfa/Config.hpp"
#include "psfa/CheckData.hpp"




psfa::Admin::Admin() 
  : db_( 0 ),
    success_( false )
{


}



psfa::Admin::~Admin() 
{
  delete db_;
  db_ = 0;
}



void
psfa::Admin::init() 
{
  setUpEnviroment();
  if( !success_ ) {
    return;
  }
  db_->initPsfa();
  return;
}



void
psfa::Admin::del( const std::string poolName ) 
{
  setUpEnviroment();
  if( !success_ ) {
    return;
  }
  if( db_->existPool( poolName ) ) {
    db_->delPool( poolName );
    success_ = true;
    return;
  }
  std::cout << "Fehler: Der Pool " 
       << poolName 
       << " existiert nicht." 
       << std::endl;
  success_ = false;
  return;
}



void
psfa::Admin::index( const std::string poolName ) 
{
  setUpEnviroment();
  if( !success_ ) {
    return;
  }
  if( !db_->existPool( poolName ) ) {
    std::cout << "Fehler: Der Pool " 
         << poolName 
         << " existiert nicht." 
         << std::endl;
    success_ = false;
    return;
  }
  
  CheckData data;
  db_->check( data );
  if( data.init ) {
    std::cout << "Die Konfiguration und die Datenbank stimmen nicht überein.\n"
         << "Es wird geraten 'psfa init' auszuführen."
         << "Die Aktion wurde abgebrochen."
         << std::endl;
    return;
  }
  int count = db_->index( poolName, data );
  std::cout << "Im Pool "
       << poolName
       << " sind "
       << count
       << " Tags indiziert."
       << std::endl;
  success_ = db_->success();
  return;
}



void
psfa::Admin::check() 
{
  using std::cout;
  using std::endl;
  using std::string;
  using std::ostream_iterator;

  setUpEnviroment();
  if( !success_ ) {
    return;
  }

  bool upToDate = true;
  CheckData data;
  db_->check( data );
  if( data.init ) {
    cout << "Die Konfiguration und die Datenbank stimmen nicht überein.\n"
    << "Es wird geraten 'psfa init' und danach "
    << "'psfa index Poolname' auszuführen.";
    if( data.poolDel ) {
      cout << "\n"
      << "Außerdem befinden sich in der Datenbank noch folgende Pools,\n"
      << "die nicht mehr in der Konfiguration enthalten sind:\n"
      << "\n";
      copy( data.poolDelList.begin(),
       data.poolDelList.end(),
       ostream_iterator<string>( cout, " " ) );
      cout << "\n\n";
      cout << "Sie sollten mit 'psfa delete Poolname' gelöscht werden";
    }
    cout << endl;
    upToDate = false;
  }
  bool index = false;
  if( data.poolIndex && upToDate ) {
    cout << "Folgende Dateien sind noch nicht indiziert:\n";
    typedef std::map< std::string, std::vector< std::string > > vMap;
    typedef std::vector< std::string > sVec;
    vMap::iterator i;
    vMap::iterator iEnd = data.poolIndexList.end();
    for( i = data.poolIndexList.begin(); i != iEnd; ++i ) {
      sVec tmp = i->second;
      cout << "Im Pool: " << i->first << "\n";
      copy( tmp.begin(),
       tmp.end(),
       ostream_iterator<string>( cout, " " ) );
      cout << endl;
    }
    index = true;
  }
  if( data.poolInsert && upToDate ) {
    cout << "Folgende Dateien sind neu (und nicht indiziert):\n";
    typedef std::map< std::string, std::vector< std::string > > vMap;
    typedef std::vector< std::string > sVec;
    vMap::iterator i;
    vMap::iterator iEnd = data.poolInsertList.end();
    for( i = data.poolInsertList.begin(); i != iEnd; ++i ) {
      sVec tmp = i->second;
      if( !tmp.empty() ) {
   cout << "Im Pool: " << i->first << "\n";
   copy( tmp.begin(),
         tmp.end(),
         ostream_iterator<string>( cout, " " ) );
   cout << endl;
      }
    }
    index = true;
  }
  if( data.poolUpdate && upToDate ) {
    cout << "Folgende Dateien wurden geändert:\n";
    typedef std::map< std::string, std::vector< std::string > > vMap;
    typedef std::vector< std::string > sVec;
    vMap::iterator i;
    vMap::iterator iEnd = data.poolUpdateList.end();
    for( i = data.poolUpdateList.begin(); i != iEnd; ++i ) {
      sVec tmp = i->second;
      if( !tmp.empty() ) {
   cout << "Im Pool: " << i->first << "\n";
   copy( tmp.begin(),
         tmp.end(),
         ostream_iterator<string>( cout, " " ) );
   cout << endl;
      }
    }
    index = true;
  }
  if( data.poolRemove && upToDate ) {
    cout << "Folgende Dateien wurden gelöscht:\n";
    typedef std::map< std::string, std::vector< std::string > > vMap;
    typedef std::vector< std::string > sVec;
    vMap::iterator i;
    vMap::iterator iEnd = data.poolRemoveList.end();
    for( i = data.poolRemoveList.begin(); i != iEnd; ++i ) {
      sVec tmp = i->second;
      if( !tmp.empty() ) {
   cout << "Im Pool: " << i->first << "\n";
   copy( tmp.begin(),
         tmp.end(),
         ostream_iterator<string>( cout, " " ) );
   cout << endl;
      }
      
    }
    index = true;
  }
  if( index ) {
    cout << "Es wird geraten 'psfa index Poolname' auszuführen."
    << endl;
    upToDate = false;
  }
  if ( upToDate ) {
    cout << "Es ist alles auf dem letzten Stand." << endl;
  }
  cout << "Die Anzahl der indizierten Tags lautet:\n";
  typedef std::map< std::string, int > iMap;
  iMap::iterator i;
  iMap::iterator iEnd = data.indexCountList.end();
  for( i = data.indexCountList.begin(); i != iEnd; ++i ) {
    cout << "Im Pool: " 
    << i->first 
    << ", "
    << i->second
    << endl;
  }

  success_ = true;
  return;
}



bool
psfa::Admin::isSuccess() const
{
  return success_;
}



void
psfa::Admin::setUpEnviroment() 
{
  using std::cout;
  using std::endl;
  using psfahelper::getFilePaths;
  using psfahelper::splitString;
  using psfahelper::pathIsReadable;
  using psfahelper::pathIsDir;
  typedef std::vector< std::string > sVec;

  bool success = true;
  
  sVec psfaConfigs;
  psfaConfigs.reserve( 3 );
  const char* env = getenv("PSFA_CONFIG");
  if ( env ) {
    std::string pC( env );
    if( pathIsReadable( pC ) ) {
      psfaConfigs.push_back( pC );
    }
    delete env;
  }
  env = getenv("HOME");
  if ( env ) {
    std::string h( env );
    h += "/.psfa/psfa_conf.xml";
    if( pathIsReadable( h ) ) {
      psfaConfigs.push_back( h );
    }
    delete env;
  }
  std::string etc("/etc/psfa_conf.xml");
  if( pathIsReadable( etc ) ) {
    psfaConfigs.push_back( etc );
  }
  
  if( psfaConfigs.empty() ) {
    cout << "Es wurde keine Konfiguration gefunden.\n"
    << "Der Vorgang wurde abgebrochen."
    << endl;
    success_ = false;
    return;
  }
  
  Config* conf = Config::getConfig();
  sVec::iterator i;
  sVec::iterator iEnd = psfaConfigs.end();
  for( i = psfaConfigs.begin(); i != iEnd; ++i ) {
      conf->parseConfig( *i );
  }
  std::string pools = conf->getConfigValue( "psfa", "pools" );
  sVec inConfig;
  splitString( pools, inConfig );
  if( inConfig.empty() ) {
    cout << "Es sind keine Pools in der Konfiguration angegeben."
    << endl;
    success = false;
  }
  sVec::iterator p;
  sVec::iterator pEnd = inConfig.end();
  for( p = inConfig.begin(); p != pEnd; ++p ) {
    sVec tmpV;
    std::string tmpS;

    tmpS = conf->getConfigValue( *p, "tags" );
    splitString( tmpS, tmpV );
    if( tmpV.empty() ) {
      cout << "Für den Pool "
      << *p
      << " sind keine Tags, die indiziert werden sollen, angegeben."
      << endl;
      success = false;
    }

    tmpV.clear();
    tmpS = conf->getConfigValue( *p, "kontexts" );
    splitString( tmpS, tmpV );
    if( tmpV.empty() ) {
      cout << "Für den Pool "
      << *p
      << " sind keine Kontexte angegeben."
      << endl;
      success = false;
    }

    tmpS = conf->getConfigValue( *p, "root" );
    bool b = pathIsDir( tmpS );
    if( !b ) {
      cout << "Das Root-Verzeichnis des Pools "
      << *p
      << ", "
      << tmpS
      << ", ist kein Verzeichnis."
      << endl;
      success = false;
    }
    b = pathIsReadable( tmpS );
    if( !b ) {
      cout << "Das Root-Verzeichnis des Pools "
      << *p
      << ", "
      << tmpS
      << ", ist für den aktuellen Benutzer nicht lesbar."
      << endl;
      success = false;
    }

    tmpV.clear();
    getFilePaths( tmpS, "*.xml", tmpV );
    if( tmpV.empty() ) {
      cout << "Das Root-Verzeichnis des Pools "
      << *p
      << ", "
      << tmpS
      << ", enthält keine Dateien."
      << endl;
      success = false;
    }
    
    tmpS = conf->getConfigValue( *p, "unitTag" );
    if( tmpS.empty() ) {
      cout << "Für den Pool "
      << *p
      << " ist nicht angegeben, wie eine Einheit ermittelt werden kann."
      << endl;
      success = false;
    }
  }

  std::string tmpS;

  tmpS = conf->getConfigValue( "mysql", "host" );
  if( tmpS.empty() ) {
    cout << "Es fehlt die Angabe des Datanbank Hosts."
    << endl;
    success = false;
  }
  tmpS = conf->getConfigValue( "mysql", "user" );
  if( tmpS.empty() ) {
    cout << "Es fehlt die Angabe des Datanbank Users."
    << endl;
    success = false;
  }
  tmpS = conf->getConfigValue( "mysql", "password" );
  if( tmpS.empty() ) {
    cout << "Es fehlt die Angabe des Datanbank Passwortes."
    << endl;
    success = false;
  }
  tmpS = conf->getConfigValue( "mysql", "db" );
  if( tmpS.empty() ) {
    cout << "Es fehlt die Angabe des Datanbanknamens."
    << endl;
    success = false;
  }

  if( !success ) {
    cout << "Die Aktion wurde aufgrund der Fehler abgebrochen."
    << endl;
    return;
  }

  db_ = new DbWriteDriverMySql;
  success_ = true;
  return;
}

---