UserConfig.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_USERCONFIG_H__
#define __ARC_USERCONFIG_H__

#include <list>
#include <vector>
#include <string>

#include <arc/ArcConfig.h>
#include <arc/DateTime.h>
#include <arc/URL.h>
#include <arc/User.h>

namespace Arc {

  class Logger;
  class XMLNode;

  enum ServiceType {
    COMPUTING, 
    INDEX      
  };


  class ConfigEndpoint {
  public:
    enum Type {
      REGISTRY,      
      COMPUTINGINFO, 
      ANY            
    };


    ConfigEndpoint(const std::string& URLString = "", const std::string& InterfaceName = "", ConfigEndpoint::Type type = ConfigEndpoint::ANY)
      : type(type), URLString(URLString), InterfaceName(InterfaceName) {}
      
    Type type;
    
    std::string URLString;
    
    std::string InterfaceName;
        

    std::string RequestedSubmissionInterfaceName;

    operator bool() const {
      return (!URLString.empty());
    }

    bool operator!() const {
      return (URLString.empty());
    }
    
    bool operator==(ConfigEndpoint c) const {
      return (type == c.type) && (URLString == c.URLString) && (InterfaceName == c.InterfaceName) && (RequestedSubmissionInterfaceName == c.RequestedSubmissionInterfaceName);
    }
  };

  std::string tostring(const ServiceType st);


  class initializeCredentialsType {
   public:
    typedef enum {
      SkipCredentials,         
      NotTryCredentials,       
      TryCredentials,          
      RequireCredentials,      
      SkipCANotTryCredentials, 
      SkipCATryCredentials,    
      SkipCARequireCredentials 
    } initializeType;
    initializeCredentialsType(void):val(TryCredentials) { };
    initializeCredentialsType(initializeType v):val(v) { };
    bool operator==(initializeType v) { return (val == v); };
    bool operator!=(initializeType v) { return (val != v); };
    operator initializeType(void) { return val; };
   private:
    initializeType val;
  };


  class UserConfig {
  public:

    UserConfig(initializeCredentialsType initializeCredentials = initializeCredentialsType());

    UserConfig(const std::string& conffile,
               initializeCredentialsType initializeCredentials = initializeCredentialsType(),
               bool loadSysConfig = true);

    UserConfig(const std::string& conffile,
               const std::string& jfile,
               initializeCredentialsType initializeCredentials = initializeCredentialsType(),
               bool loadSysConfig = true);

    UserConfig(const long int& ptraddr);
    ~UserConfig() {}


    bool InitializeCredentials(initializeCredentialsType initializeCredentials);

    bool CredentialsFound() const {
      return !((proxyPath.empty() && (certificatePath.empty() || keyPath.empty())) || caCertificatesDirectory.empty());
    }


    bool LoadConfigurationFile(const std::string& conffile, bool ignoreJobListFile = true);


    bool SaveToFile(const std::string& filename) const;


    void ApplyToConfig(BaseConfig& ccfg) const;


    operator bool() const { return ok; }

    bool operator!() const { return !ok; }


    bool JobListFile(const std::string& path);

    const std::string& JobListFile() const { return joblistfile; }
    

    bool JobListType(const std::string& type);

    const std::string& JobListType() const { return joblisttype; }


    bool Timeout(int newTimeout);

    int  Timeout() const { return timeout; }


    bool Verbosity(const std::string& newVerbosity);

    const std::string& Verbosity() const { return verbosity; }


    bool Broker(const std::string& name);

    bool Broker(const std::string& name, const std::string& argument) { broker = std::pair<std::string, std::string>(name, argument); return true;}

    const std::pair<std::string, std::string>& Broker() const { return broker; }


    bool VOMSESPath(const std::string& path) { vomsesPath = path; return true; }

    const std::string& VOMSESPath();


    const std::list<std::string>& DefaultVOMSes() const { return defaultVomses; };


    bool UserName(const std::string& name) { username = name; return true; }

    const std::string& UserName() const { return username; }


    bool Password(const std::string& newPassword) { password = newPassword; return true; }

    const std::string& Password() const { return password; }


    void CredentialString(const std::string& cred) { credentialString = cred; }

    const std::string& CredentialString() const { return credentialString; }


    void OToken(const std::string& token) { otoken = token; }

    const std::string& OToken() const { return otoken; }


    bool ProxyPath(const std::string& newProxyPath) { proxyPath = newProxyPath; return true;}

    const std::string& ProxyPath() const { return proxyPath; }


    bool CertificatePath(const std::string& newCertificatePath) { certificatePath = newCertificatePath; return true; }

    const std::string& CertificatePath() const { return certificatePath; }


    bool KeyPath(const std::string& newKeyPath) { keyPath = newKeyPath; return true; }

    const std::string& KeyPath() const { return keyPath; }


    bool KeyPassword(const std::string& newKeyPassword) { keyPassword = newKeyPassword; return true; }

    const std::string& KeyPassword() const { return keyPassword; }


    bool KeySize(int newKeySize) { keySize = newKeySize; return true;}

    int KeySize() const { return keySize; }


    bool CACertificatePath(const std::string& newCACertificatePath) { caCertificatePath = newCACertificatePath; return true; }

    const std::string& CACertificatePath() const { return caCertificatePath; }


    bool CACertificatesDirectory(const std::string& newCACertificatesDirectory) { caCertificatesDirectory = newCACertificatesDirectory; return true; }

    const std::string& CACertificatesDirectory() const { return caCertificatesDirectory; }


    bool CertificateLifeTime(const Period& newCertificateLifeTime) { certificateLifeTime = newCertificateLifeTime; return true; }

    const Period& CertificateLifeTime() const { return certificateLifeTime; }


    bool SLCS(const URL& newSLCS) { slcs = newSLCS; return true; }

    const URL& SLCS() const { return slcs; }


    bool IsSameIdentity(UserConfig const & other) const {
      if(credentialString != other.credentialString) return false;
      if(proxyPath != other.proxyPath) return false;
      if(certificatePath != other.certificatePath) return false;
      if(username != other.username) return false;
      if(otoken != other.otoken) return false;
      return true;
    }


    bool StoreDirectory(const std::string& newStoreDirectory) { storeDirectory = newStoreDirectory; return true; }

    const std::string& StoreDirectory() const { return storeDirectory; }


    bool JobDownloadDirectory(const std::string& newDownloadDirectory) { downloadDirectory = newDownloadDirectory; return true; }


    const std::string& JobDownloadDirectory() const { return downloadDirectory; }


    bool IdPName(const std::string& name) { idPName = name; return true; }

    const std::string& IdPName() const { return idPName; }


    bool OverlayFile(const std::string& path) { overlayfile = path; return true; }

    const std::string& OverlayFile() const { return overlayfile; }


    bool UtilsDirPath(const std::string& dir);

    const std::string& UtilsDirPath() const { return utilsdir; };


    void SetUser(const User& u) { user = u; };


    const User& GetUser() const { return user; };


    bool InfoInterface(const std::string& infointerface_) {
      infointerface = infointerface_;
      return true;
    }

    const std::string& InfoInterface() const { return infointerface; };


    bool SubmissionInterface(const std::string& submissioninterface_) {
      submissioninterface = submissioninterface_;
      return true;
    }

    const std::string& SubmissionInterface() const { return submissioninterface; };


    const std::list<std::string>& RejectDiscoveryURLs() const { return rejectDiscoveryURLs; };

    void AddRejectDiscoveryURLs(const std::list<std::string>& urls) { rejectDiscoveryURLs.insert(rejectDiscoveryURLs.end(), urls.begin(), urls.end()); }

    void ClearRejectDiscoveryURLs() { rejectDiscoveryURLs.clear(); }
    

    const std::list<std::string>& RejectManagementURLs() const { return rejectManagementURLs; };



    ConfigEndpoint GetService(const std::string& alias);


    std::list<ConfigEndpoint> GetServicesInGroup(const std::string& group, ConfigEndpoint::Type type = ConfigEndpoint::ANY);


    std::list<ConfigEndpoint> GetDefaultServices(ConfigEndpoint::Type type = ConfigEndpoint::ANY);


    std::list<ConfigEndpoint> GetServices(const std::string& groupOrAlias, ConfigEndpoint::Type type = ConfigEndpoint::ANY);

    std::map<std::string, ConfigEndpoint> GetAllConfiguredServices() { return allServices; }



    static std::string ARCUSERDIRECTORY();

    static std::string SYSCONFIG();

    static std::string SYSCONFIGARCLOC();

    static std::string DEFAULTCONFIG();

    static std::string EXAMPLECONFIG();

    static std::string JOBLISTFILE();


    static const int DEFAULT_TIMEOUT = 20;


    static std::string DEFAULT_BROKER();

  private:

    static ConfigEndpoint ServiceFromLegacyString(std::string);

    void setDefaults();
    static bool makeDir(const std::string& path);
    static bool copyFile(const std::string& source,
                         const std::string& destination);
    bool CreateDefaultConfigurationFile() const;

    std::list<ConfigEndpoint> FilterServices(const std::list<ConfigEndpoint>&, ConfigEndpoint::Type);


    std::string joblistfile;
    std::string joblisttype;

    int timeout;

    std::string verbosity;

    // Broker name and arguments.
    std::pair<std::string, std::string> broker;

    std::list<ConfigEndpoint> defaultServices;
    std::map<std::string, ConfigEndpoint> allServices;
    std::map<std::string, std::list<ConfigEndpoint> > groupMap;
    std::list<std::string> rejectDiscoveryURLs;
    std::list<std::string> rejectManagementURLs;

    std::string credentialString;
    std::string otoken;
    std::string proxyPath;
    std::string certificatePath;
    std::string keyPath;
    std::string keyPassword;
    int keySize;
    std::string caCertificatePath;
    std::string caCertificatesDirectory;
    Period certificateLifeTime;

    URL slcs;

    std::string vomsesPath;
    std::list<std::string> defaultVomses;

    std::string storeDirectory;
    std::string downloadDirectory;
    std::string idPName;

    std::string username;
    std::string password;

    std::string overlayfile;
    std::string utilsdir;

    std::string submissioninterface;
    std::string infointerface;
    // User whose identity (uid/gid) should be used to access filesystem
    // Normally this is the same as the process owner
    User user;
    // Private members not refered to outside this class:
    bool ok;

    initializeCredentialsType initializeCredentials;

    static Logger logger;
  };



  class CertEnvLocker {
  public:
    CertEnvLocker(const UserConfig& cfg);
    ~CertEnvLocker(void);

  protected:
    std::string x509_user_key_old;
    std::string x509_user_key_new;
    bool x509_user_key_set;
    std::string x509_user_cert_old;
    std::string x509_user_cert_new;
    bool x509_user_cert_set;
    std::string x509_user_proxy_old;
    std::string x509_user_proxy_new;
    bool x509_user_proxy_set;
    std::string ca_cert_dir_old;
    bool ca_cert_dir_set;
  };

} // namespace Arc

#endif // __ARC_USERCONFIG_H__